debugcommands: drop offset and length from debugindex by default

These fields are an implementation detail of revlog storage. As
such, they are not part of the generic storage "index" interface
and shouldn't be displayed by default.

Because we don't have another way to display these fields, we've
retained support for printing these fields via --verbose.

Yes, I know we should probably be doing all this formatting using
modern formatting/templater APIs. I didn't feel like scope
bloating this patch.

Differential Revision: https://phab.mercurial-scm.org/D3028

mercurial/debugcommands.py

@@ -1,3056 +1,3075 b''
 # debugcommands.py - command processing for debug* commands
 #
 # Copyright 2005-2016 Matt 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.
 
 from __future__ import absolute_import
 
 import codecs
 import collections
 import difflib
 import errno
 import operator
 import os
 import random
 import re
 import socket
 import ssl
 import stat
 import string
 import subprocess
 import sys
 import tempfile
 import time
 
 from .i18n import _
 from .node import (
     bin,
     hex,
     nullhex,
     nullid,
     nullrev,
     short,
 )
 from . import (
     bundle2,
     changegroup,
     cmdutil,
     color,
     context,
     dagparser,
     dagutil,
     encoding,
     error,
     exchange,
     extensions,
     filemerge,
     fileset,
     formatter,
     hg,
     httppeer,
     localrepo,
     lock as lockmod,
     logcmdutil,
     merge as mergemod,
     obsolete,
     obsutil,
     phases,
     policy,
     pvec,
     pycompat,
     registrar,
     repair,
     revlog,
     revset,
     revsetlang,
     scmutil,
     setdiscovery,
     simplemerge,
     smartset,
     sshpeer,
     sslutil,
     streamclone,
     templater,
     treediscovery,
     upgrade,
     url as urlmod,
     util,
     vfs as vfsmod,
     wireprotoframing,
     wireprotoserver,
 )
 from .utils import (
     dateutil,
     procutil,
     stringutil,
 )
 
 release = lockmod.release
 
 command = registrar.command()
 
 @command('debugancestor', [], _('[INDEX] REV1 REV2'), optionalrepo=True)
 def debugancestor(ui, repo, *args):
     """find the ancestor revision of two revisions in a given index"""
     if len(args) == 3:
         index, rev1, rev2 = args
         r = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False), index)
         lookup = r.lookup
     elif len(args) == 2:
         if not repo:
             raise error.Abort(_('there is no Mercurial repository here '
                                 '(.hg not found)'))
         rev1, rev2 = args
         r = repo.changelog
         lookup = repo.lookup
     else:
         raise error.Abort(_('either two or three arguments required'))
     a = r.ancestor(lookup(rev1), lookup(rev2))
     ui.write('%d:%s\n' % (r.rev(a), hex(a)))
 
 @command('debugapplystreamclonebundle', [], 'FILE')
 def debugapplystreamclonebundle(ui, repo, fname):
     """apply a stream clone bundle file"""
     f = hg.openpath(ui, fname)
     gen = exchange.readbundle(ui, f, fname)
     gen.apply(repo)
 
 @command('debugbuilddag',
     [('m', 'mergeable-file', None, _('add single file mergeable changes')),
     ('o', 'overwritten-file', None, _('add single file all revs overwrite')),
     ('n', 'new-file', None, _('add new file at each rev'))],
     _('[OPTION]... [TEXT]'))
 def debugbuilddag(ui, repo, text=None,
                   mergeable_file=False,
                   overwritten_file=False,
                   new_file=False):
     """builds a repo with a given DAG from scratch in the current empty repo
 
     The description of the DAG is read from stdin if not given on the
     command line.
 
     Elements:
 
      - "+n" is a linear run of n nodes based on the current default parent
      - "." is a single node based on the current default parent
      - "$" resets the default parent to null (implied at the start);
            otherwise the default parent is always the last node created
      - "<p" sets the default parent to the backref p
      - "*p" is a fork at parent p, which is a backref
      - "*p1/p2" is a merge of parents p1 and p2, which are backrefs
      - "/p2" is a merge of the preceding node and p2
      - ":tag" defines a local tag for the preceding node
      - "@branch" sets the named branch for subsequent nodes
      - "#...\\n" is a comment up to the end of the line
 
     Whitespace between the above elements is ignored.
 
     A backref is either
 
      - a number n, which references the node curr-n, where curr is the current
        node, or
      - the name of a local tag you placed earlier using ":tag", or
      - empty to denote the default parent.
 
     All string valued-elements are either strictly alphanumeric, or must
     be enclosed in double quotes ("..."), with "\\" as escape character.
     """
 
     if text is None:
         ui.status(_("reading DAG from stdin\n"))
         text = ui.fin.read()
 
     cl = repo.changelog
     if len(cl) > 0:
         raise error.Abort(_('repository is not empty'))
 
     # determine number of revs in DAG
     total = 0
     for type, data in dagparser.parsedag(text):
         if type == 'n':
             total += 1
 
     if mergeable_file:
         linesperrev = 2
         # make a file with k lines per rev
         initialmergedlines = ['%d' % i for i in xrange(0, total * linesperrev)]
         initialmergedlines.append("")
 
     tags = []
 
     wlock = lock = tr = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         tr = repo.transaction("builddag")
 
         at = -1
         atbranch = 'default'
         nodeids = []
         id = 0
         ui.progress(_('building'), id, unit=_('revisions'), total=total)
         for type, data in dagparser.parsedag(text):
             if type == 'n':
                 ui.note(('node %s\n' % pycompat.bytestr(data)))
                 id, ps = data
 
                 files = []
                 filecontent = {}
 
                 p2 = None
                 if mergeable_file:
                     fn = "mf"
                     p1 = repo[ps[0]]
                     if len(ps) > 1:
                         p2 = repo[ps[1]]
                         pa = p1.ancestor(p2)
                         base, local, other = [x[fn].data() for x in (pa, p1,
                                                                      p2)]
                         m3 = simplemerge.Merge3Text(base, local, other)
                         ml = [l.strip() for l in m3.merge_lines()]
                         ml.append("")
                     elif at > 0:
                         ml = p1[fn].data().split("\n")
                     else:
                         ml = initialmergedlines
                     ml[id * linesperrev] += " r%i" % id
                     mergedtext = "\n".join(ml)
                     files.append(fn)
                     filecontent[fn] = mergedtext
 
                 if overwritten_file:
                     fn = "of"
                     files.append(fn)
                     filecontent[fn] = "r%i\n" % id
 
                 if new_file:
                     fn = "nf%i" % id
                     files.append(fn)
                     filecontent[fn] = "r%i\n" % id
                     if len(ps) > 1:
                         if not p2:
                             p2 = repo[ps[1]]
                         for fn in p2:
                             if fn.startswith("nf"):
                                 files.append(fn)
                                 filecontent[fn] = p2[fn].data()
 
                 def fctxfn(repo, cx, path):
                     if path in filecontent:
                         return context.memfilectx(repo, cx, path,
                                                   filecontent[path])
                     return None
 
                 if len(ps) == 0 or ps[0] < 0:
                     pars = [None, None]
                 elif len(ps) == 1:
                     pars = [nodeids[ps[0]], None]
                 else:
                     pars = [nodeids[p] for p in ps]
                 cx = context.memctx(repo, pars, "r%i" % id, files, fctxfn,
                                     date=(id, 0),
                                     user="debugbuilddag",
                                     extra={'branch': atbranch})
                 nodeid = repo.commitctx(cx)
                 nodeids.append(nodeid)
                 at = id
             elif type == 'l':
                 id, name = data
                 ui.note(('tag %s\n' % name))
                 tags.append("%s %s\n" % (hex(repo.changelog.node(id)), name))
             elif type == 'a':
                 ui.note(('branch %s\n' % data))
                 atbranch = data
             ui.progress(_('building'), id, unit=_('revisions'), total=total)
         tr.close()
 
         if tags:
             repo.vfs.write("localtags", "".join(tags))
     finally:
         ui.progress(_('building'), None)
         release(tr, lock, wlock)
 
 def _debugchangegroup(ui, gen, all=None, indent=0, **opts):
     indent_string = ' ' * indent
     if all:
         ui.write(("%sformat: id, p1, p2, cset, delta base, len(delta)\n")
                  % indent_string)
 
         def showchunks(named):
             ui.write("\n%s%s\n" % (indent_string, named))
             for deltadata in gen.deltaiter():
                 node, p1, p2, cs, deltabase, delta, flags = deltadata
                 ui.write("%s%s %s %s %s %s %d\n" %
                          (indent_string, hex(node), hex(p1), hex(p2),
                           hex(cs), hex(deltabase), len(delta)))
 
         chunkdata = gen.changelogheader()
         showchunks("changelog")
         chunkdata = gen.manifestheader()
         showchunks("manifest")
         for chunkdata in iter(gen.filelogheader, {}):
             fname = chunkdata['filename']
             showchunks(fname)
     else:
         if isinstance(gen, bundle2.unbundle20):
             raise error.Abort(_('use debugbundle2 for this file'))
         chunkdata = gen.changelogheader()
         for deltadata in gen.deltaiter():
             node, p1, p2, cs, deltabase, delta, flags = deltadata
             ui.write("%s%s\n" % (indent_string, hex(node)))
 
 def _debugobsmarkers(ui, part, indent=0, **opts):
     """display version and markers contained in 'data'"""
     opts = pycompat.byteskwargs(opts)
     data = part.read()
     indent_string = ' ' * indent
     try:
         version, markers = obsolete._readmarkers(data)
     except error.UnknownVersion as exc:
         msg = "%sunsupported version: %s (%d bytes)\n"
         msg %= indent_string, exc.version, len(data)
         ui.write(msg)
     else:
         msg = "%sversion: %d (%d bytes)\n"
         msg %= indent_string, version, len(data)
         ui.write(msg)
         fm = ui.formatter('debugobsolete', opts)
         for rawmarker in sorted(markers):
             m = obsutil.marker(None, rawmarker)
             fm.startitem()
             fm.plain(indent_string)
             cmdutil.showmarker(fm, m)
         fm.end()
 
 def _debugphaseheads(ui, data, indent=0):
     """display version and markers contained in 'data'"""
     indent_string = ' ' * indent
     headsbyphase = phases.binarydecode(data)
     for phase in phases.allphases:
         for head in headsbyphase[phase]:
             ui.write(indent_string)
             ui.write('%s %s\n' % (hex(head), phases.phasenames[phase]))
 
 def _quasirepr(thing):
     if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):
         return '{%s}' % (
             b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing)))
     return pycompat.bytestr(repr(thing))
 
 def _debugbundle2(ui, gen, all=None, **opts):
     """lists the contents of a bundle2"""
     if not isinstance(gen, bundle2.unbundle20):
         raise error.Abort(_('not a bundle2 file'))
     ui.write(('Stream params: %s\n' % _quasirepr(gen.params)))
     parttypes = opts.get(r'part_type', [])
     for part in gen.iterparts():
         if parttypes and part.type not in parttypes:
             continue
         ui.write('%s -- %s\n' % (part.type, _quasirepr(part.params)))
         if part.type == 'changegroup':
             version = part.params.get('version', '01')
             cg = changegroup.getunbundler(version, part, 'UN')
             if not ui.quiet:
                 _debugchangegroup(ui, cg, all=all, indent=4, **opts)
         if part.type == 'obsmarkers':
             if not ui.quiet:
                 _debugobsmarkers(ui, part, indent=4, **opts)
         if part.type == 'phase-heads':
             if not ui.quiet:
                 _debugphaseheads(ui, part, indent=4)
 
 @command('debugbundle',
         [('a', 'all', None, _('show all details')),
          ('', 'part-type', [], _('show only the named part type')),
          ('', 'spec', None, _('print the bundlespec of the bundle'))],
         _('FILE'),
         norepo=True)
 def debugbundle(ui, bundlepath, all=None, spec=None, **opts):
     """lists the contents of a bundle"""
     with hg.openpath(ui, bundlepath) as f:
         if spec:
             spec = exchange.getbundlespec(ui, f)
             ui.write('%s\n' % spec)
             return
 
         gen = exchange.readbundle(ui, f, bundlepath)
         if isinstance(gen, bundle2.unbundle20):
             return _debugbundle2(ui, gen, all=all, **opts)
         _debugchangegroup(ui, gen, all=all, **opts)
 
 @command('debugcapabilities',
         [], _('PATH'),
         norepo=True)
 def debugcapabilities(ui, path, **opts):
     """lists the capabilities of a remote peer"""
     opts = pycompat.byteskwargs(opts)
     peer = hg.peer(ui, opts, path)
     caps = peer.capabilities()
     ui.write(('Main capabilities:\n'))
     for c in sorted(caps):
         ui.write(('  %s\n') % c)
     b2caps = bundle2.bundle2caps(peer)
     if b2caps:
         ui.write(('Bundle2 capabilities:\n'))
         for key, values in sorted(b2caps.iteritems()):
             ui.write(('  %s\n') % key)
             for v in values:
                 ui.write(('    %s\n') % v)
 
 @command('debugcheckstate', [], '')
 def debugcheckstate(ui, repo):
     """validate the correctness of the current dirstate"""
     parent1, parent2 = repo.dirstate.parents()
     m1 = repo[parent1].manifest()
     m2 = repo[parent2].manifest()
     errors = 0
     for f in repo.dirstate:
         state = repo.dirstate[f]
         if state in "nr" and f not in m1:
             ui.warn(_("%s in state %s, but not in manifest1\n") % (f, state))
             errors += 1
         if state in "a" and f in m1:
             ui.warn(_("%s in state %s, but also in manifest1\n") % (f, state))
             errors += 1
         if state in "m" and f not in m1 and f not in m2:
             ui.warn(_("%s in state %s, but not in either manifest\n") %
                     (f, state))
             errors += 1
     for f in m1:
         state = repo.dirstate[f]
         if state not in "nrm":
             ui.warn(_("%s in manifest1, but listed as state %s") % (f, state))
             errors += 1
     if errors:
         error = _(".hg/dirstate inconsistent with current parent's manifest")
         raise error.Abort(error)
 
 @command('debugcolor',
         [('', 'style', None, _('show all configured styles'))],
         'hg debugcolor')
 def debugcolor(ui, repo, **opts):
     """show available color, effects or style"""
     ui.write(('color mode: %s\n') % ui._colormode)
     if opts.get(r'style'):
         return _debugdisplaystyle(ui)
     else:
         return _debugdisplaycolor(ui)
 
 def _debugdisplaycolor(ui):
     ui = ui.copy()
     ui._styles.clear()
     for effect in color._activeeffects(ui).keys():
         ui._styles[effect] = effect
     if ui._terminfoparams:
         for k, v in ui.configitems('color'):
             if k.startswith('color.'):
                 ui._styles[k] = k[6:]
             elif k.startswith('terminfo.'):
                 ui._styles[k] = k[9:]
     ui.write(_('available colors:\n'))
     # sort label with a '_' after the other to group '_background' entry.
     items = sorted(ui._styles.items(),
                    key=lambda i: ('_' in i[0], i[0], i[1]))
     for colorname, label in items:
         ui.write(('%s\n') % colorname, label=label)
 
 def _debugdisplaystyle(ui):
     ui.write(_('available style:\n'))
     width = max(len(s) for s in ui._styles)
     for label, effects in sorted(ui._styles.items()):
         ui.write('%s' % label, label=label)
         if effects:
             # 50
             ui.write(': ')
             ui.write(' ' * (max(0, width - len(label))))
             ui.write(', '.join(ui.label(e, e) for e in effects.split()))
         ui.write('\n')
 
 @command('debugcreatestreamclonebundle', [], 'FILE')
 def debugcreatestreamclonebundle(ui, repo, fname):
     """create a stream clone bundle file
 
     Stream bundles are special bundles that are essentially archives of
     revlog files. They are commonly used for cloning very quickly.
     """
     # TODO we may want to turn this into an abort when this functionality
     # is moved into `hg bundle`.
     if phases.hassecret(repo):
         ui.warn(_('(warning: stream clone bundle will contain secret '
                   'revisions)\n'))
 
     requirements, gen = streamclone.generatebundlev1(repo)
     changegroup.writechunks(ui, gen, fname)
 
     ui.write(_('bundle requirements: %s\n') % ', '.join(sorted(requirements)))
 
 @command('debugdag',
     [('t', 'tags', None, _('use tags as labels')),
     ('b', 'branches', None, _('annotate with branch names')),
     ('', 'dots', None, _('use dots for runs')),
     ('s', 'spaces', None, _('separate elements by spaces'))],
     _('[OPTION]... [FILE [REV]...]'),
     optionalrepo=True)
 def debugdag(ui, repo, file_=None, *revs, **opts):
     """format the changelog or an index DAG as a concise textual description
 
     If you pass a revlog index, the revlog's DAG is emitted. If you list
     revision numbers, they get labeled in the output as rN.
 
     Otherwise, the changelog DAG of the current repo is emitted.
     """
     spaces = opts.get(r'spaces')
     dots = opts.get(r'dots')
     if file_:
         rlog = revlog.revlog(vfsmod.vfs(pycompat.getcwd(), audit=False),
                              file_)
         revs = set((int(r) for r in revs))
         def events():
             for r in rlog:
                 yield 'n', (r, list(p for p in rlog.parentrevs(r)
                                         if p != -1))
                 if r in revs:
                     yield 'l', (r, "r%i" % r)
     elif repo:
         cl = repo.changelog
         tags = opts.get(r'tags')
         branches = opts.get(r'branches')
         if tags:
             labels = {}
             for l, n in repo.tags().items():
                 labels.setdefault(cl.rev(n), []).append(l)
         def events():
             b = "default"
             for r in cl:
                 if branches:
                     newb = cl.read(cl.node(r))[5]['branch']
                     if newb != b:
                         yield 'a', newb
                         b = newb
                 yield 'n', (r, list(p for p in cl.parentrevs(r)
                                         if p != -1))
                 if tags:
                     ls = labels.get(r)
                     if ls:
                         for l in ls:
                             yield 'l', (r, l)
     else:
         raise error.Abort(_('need repo for changelog dag'))
 
     for line in dagparser.dagtextlines(events(),
                                        addspaces=spaces,
                                        wraplabels=True,
                                        wrapannotations=True,
                                        wrapnonlinear=dots,
                                        usedots=dots,
                                        maxlinewidth=70):
         ui.write(line)
         ui.write("\n")
 
 @command('debugdata', cmdutil.debugrevlogopts, _('-c|-m|FILE REV'))
 def debugdata(ui, repo, file_, rev=None, **opts):
     """dump the contents of a data file revision"""
     opts = pycompat.byteskwargs(opts)
     if opts.get('changelog') or opts.get('manifest') or opts.get('dir'):
         if rev is not None:
             raise error.CommandError('debugdata', _('invalid arguments'))
         file_, rev = None, file_
     elif rev is None:
         raise error.CommandError('debugdata', _('invalid arguments'))
     r = cmdutil.openrevlog(repo, 'debugdata', file_, opts)
     try:
         ui.write(r.revision(r.lookup(rev), raw=True))
     except KeyError:
         raise error.Abort(_('invalid revision identifier %s') % rev)
 
 @command('debugdate',
     [('e', 'extended', None, _('try extended date formats'))],
     _('[-e] DATE [RANGE]'),
     norepo=True, optionalrepo=True)
 def debugdate(ui, date, range=None, **opts):
     """parse and display a date"""
     if opts[r"extended"]:
         d = dateutil.parsedate(date, util.extendeddateformats)
     else:
         d = dateutil.parsedate(date)
     ui.write(("internal: %d %d\n") % d)
     ui.write(("standard: %s\n") % dateutil.datestr(d))
     if range:
         m = dateutil.matchdate(range)
         ui.write(("match: %s\n") % m(d[0]))
 
 @command('debugdeltachain',
     cmdutil.debugrevlogopts + cmdutil.formatteropts,
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugdeltachain(ui, repo, file_=None, **opts):
     """dump information about delta chains in a revlog
 
     Output can be templatized. Available template keywords are:
 
     :``rev``:       revision number
     :``chainid``:   delta chain identifier (numbered by unique base)
     :``chainlen``:  delta chain length to this revision
     :``prevrev``:   previous revision in delta chain
     :``deltatype``: role of delta / how it was computed
     :``compsize``:  compressed size of revision
     :``uncompsize``: uncompressed size of revision
     :``chainsize``: total size of compressed revisions in chain
     :``chainratio``: total chain size divided by uncompressed revision size
                     (new delta chains typically start at ratio 2.00)
     :``lindist``:   linear distance from base revision in delta chain to end
                     of this revision
     :``extradist``: total size of revisions not part of this delta chain from
                     base of delta chain to end of this revision; a measurement
                     of how much extra data we need to read/seek across to read
                     the delta chain for this revision
     :``extraratio``: extradist divided by chainsize; another representation of
                     how much unrelated data is needed to load this delta chain
 
     If the repository is configured to use the sparse read, additional keywords
     are available:
 
     :``readsize``:     total size of data read from the disk for a revision
                        (sum of the sizes of all the blocks)
     :``largestblock``: size of the largest block of data read from the disk
     :``readdensity``:  density of useful bytes in the data read from the disk
     :``srchunks``:  in how many data hunks the whole revision would be read
 
     The sparse read can be enabled with experimental.sparse-read = True
     """
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugdeltachain', file_, opts)
     index = r.index
     generaldelta = r.version & revlog.FLAG_GENERALDELTA
     withsparseread = getattr(r, '_withsparseread', False)
 
     def revinfo(rev):
         e = index[rev]
         compsize = e[1]
         uncompsize = e[2]
         chainsize = 0
 
         if generaldelta:
             if e[3] == e[5]:
                 deltatype = 'p1'
             elif e[3] == e[6]:
                 deltatype = 'p2'
             elif e[3] == rev - 1:
                 deltatype = 'prev'
             elif e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'other'
         else:
             if e[3] == rev:
                 deltatype = 'base'
             else:
                 deltatype = 'prev'
 
         chain = r._deltachain(rev)[0]
         for iterrev in chain:
             e = index[iterrev]
             chainsize += e[1]
 
         return compsize, uncompsize, deltatype, chain, chainsize
 
     fm = ui.formatter('debugdeltachain', opts)
 
     fm.plain('    rev  chain# chainlen     prev   delta       '
              'size    rawsize  chainsize     ratio   lindist extradist '
              'extraratio')
     if withsparseread:
         fm.plain('   readsize largestblk rddensity srchunks')
     fm.plain('\n')
 
     chainbases = {}
     for rev in r:
         comp, uncomp, deltatype, chain, chainsize = revinfo(rev)
         chainbase = chain[0]
         chainid = chainbases.setdefault(chainbase, len(chainbases) + 1)
         start = r.start
         length = r.length
         basestart = start(chainbase)
         revstart = start(rev)
         lineardist = revstart + comp - basestart
         extradist = lineardist - chainsize
         try:
             prevrev = chain[-2]
         except IndexError:
             prevrev = -1
 
         chainratio = float(chainsize) / float(uncomp)
         extraratio = float(extradist) / float(chainsize)
 
         fm.startitem()
         fm.write('rev chainid chainlen prevrev deltatype compsize '
                  'uncompsize chainsize chainratio lindist extradist '
                  'extraratio',
                  '%7d %7d %8d %8d %7s %10d %10d %10d %9.5f %9d %9d %10.5f',
                  rev, chainid, len(chain), prevrev, deltatype, comp,
                  uncomp, chainsize, chainratio, lineardist, extradist,
                  extraratio,
                  rev=rev, chainid=chainid, chainlen=len(chain),
                  prevrev=prevrev, deltatype=deltatype, compsize=comp,
                  uncompsize=uncomp, chainsize=chainsize,
                  chainratio=chainratio, lindist=lineardist,
                  extradist=extradist, extraratio=extraratio)
         if withsparseread:
             readsize = 0
             largestblock = 0
             srchunks = 0
 
             for revschunk in revlog._slicechunk(r, chain):
                 srchunks += 1
                 blkend = start(revschunk[-1]) + length(revschunk[-1])
                 blksize = blkend - start(revschunk[0])
 
                 readsize += blksize
                 if largestblock < blksize:
                     largestblock = blksize
 
             readdensity = float(chainsize) / float(readsize)
 
             fm.write('readsize largestblock readdensity srchunks',
                      ' %10d %10d %9.5f %8d',
                      readsize, largestblock, readdensity, srchunks,
                      readsize=readsize, largestblock=largestblock,
                      readdensity=readdensity, srchunks=srchunks)
 
         fm.plain('\n')
 
     fm.end()
 
 @command('debugdirstate|debugstate',
     [('', 'nodates', None, _('do not display the saved mtime')),
     ('', 'datesort', None, _('sort by saved mtime'))],
     _('[OPTION]...'))
 def debugstate(ui, repo, **opts):
     """show the contents of the current dirstate"""
 
     nodates = opts.get(r'nodates')
     datesort = opts.get(r'datesort')
 
     timestr = ""
     if datesort:
         keyfunc = lambda x: (x[1][3], x[0]) # sort by mtime, then by filename
     else:
         keyfunc = None # sort by filename
     for file_, ent in sorted(repo.dirstate._map.iteritems(), key=keyfunc):
         if ent[3] == -1:
             timestr = 'unset               '
         elif nodates:
             timestr = 'set                 '
         else:
             timestr = time.strftime(r"%Y-%m-%d %H:%M:%S ",
                                     time.localtime(ent[3]))
             timestr = encoding.strtolocal(timestr)
         if ent[1] & 0o20000:
             mode = 'lnk'
         else:
             mode = '%3o' % (ent[1] & 0o777 & ~util.umask)
         ui.write("%c %s %10d %s%s\n" % (ent[0], mode, ent[2], timestr, file_))
     for f in repo.dirstate.copies():
         ui.write(_("copy: %s -> %s\n") % (repo.dirstate.copied(f), f))
 
 @command('debugdiscovery',
     [('', 'old', None, _('use old-style discovery')),
     ('', 'nonheads', None,
      _('use old-style discovery with non-heads included')),
     ('', 'rev', [], 'restrict discovery to this set of revs'),
     ] + cmdutil.remoteopts,
     _('[--rev REV] [OTHER]'))
 def debugdiscovery(ui, repo, remoteurl="default", **opts):
     """runs the changeset discovery protocol in isolation"""
     opts = pycompat.byteskwargs(opts)
     remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl))
     remote = hg.peer(repo, opts, remoteurl)
     ui.status(_('comparing with %s\n') % util.hidepassword(remoteurl))
 
     # make sure tests are repeatable
     random.seed(12323)
 
     def doit(pushedrevs, remoteheads, remote=remote):
         if opts.get('old'):
             if not util.safehasattr(remote, 'branches'):
                 # enable in-client legacy support
                 remote = localrepo.locallegacypeer(remote.local())
             common, _in, hds = treediscovery.findcommonincoming(repo, remote,
                                                                 force=True)
             common = set(common)
             if not opts.get('nonheads'):
                 ui.write(("unpruned common: %s\n") %
                          " ".join(sorted(short(n) for n in common)))
                 dag = dagutil.revlogdag(repo.changelog)
                 all = dag.ancestorset(dag.internalizeall(common))
                 common = dag.externalizeall(dag.headsetofconnecteds(all))
         else:
             nodes = None
             if pushedrevs:
                 revs = scmutil.revrange(repo, pushedrevs)
                 nodes = [repo[r].node() for r in revs]
             common, any, hds = setdiscovery.findcommonheads(ui, repo, remote,
                                                             ancestorsof=nodes)
         common = set(common)
         rheads = set(hds)
         lheads = set(repo.heads())
         ui.write(("common heads: %s\n") %
                  " ".join(sorted(short(n) for n in common)))
         if lheads <= common:
             ui.write(("local is subset\n"))
         elif rheads <= common:
             ui.write(("remote is subset\n"))
 
     remoterevs, _checkout = hg.addbranchrevs(repo, remote, branches, revs=None)
     localrevs = opts['rev']
     doit(localrevs, remoterevs)
 
 _chunksize = 4 << 10
 
 @command('debugdownload',
     [
         ('o', 'output', '', _('path')),
     ],
     optionalrepo=True)
 def debugdownload(ui, repo, url, output=None, **opts):
     """download a resource using Mercurial logic and config
     """
     fh = urlmod.open(ui, url, output)
 
     dest = ui
     if output:
         dest = open(output, "wb", _chunksize)
     try:
         data = fh.read(_chunksize)
         while data:
             dest.write(data)
             data = fh.read(_chunksize)
     finally:
         if output:
             dest.close()
 
 @command('debugextensions', cmdutil.formatteropts, [], norepo=True)
 def debugextensions(ui, **opts):
     '''show information about active extensions'''
     opts = pycompat.byteskwargs(opts)
     exts = extensions.extensions(ui)
     hgver = util.version()
     fm = ui.formatter('debugextensions', opts)
     for extname, extmod in sorted(exts, key=operator.itemgetter(0)):
         isinternal = extensions.ismoduleinternal(extmod)
         extsource = pycompat.fsencode(extmod.__file__)
         if isinternal:
             exttestedwith = []  # never expose magic string to users
         else:
             exttestedwith = getattr(extmod, 'testedwith', '').split()
         extbuglink = getattr(extmod, 'buglink', None)
 
         fm.startitem()
 
         if ui.quiet or ui.verbose:
             fm.write('name', '%s\n', extname)
         else:
             fm.write('name', '%s', extname)
             if isinternal or hgver in exttestedwith:
                 fm.plain('\n')
             elif not exttestedwith:
                 fm.plain(_(' (untested!)\n'))
             else:
                 lasttestedversion = exttestedwith[-1]
                 fm.plain(' (%s!)\n' % lasttestedversion)
 
         fm.condwrite(ui.verbose and extsource, 'source',
                  _('  location: %s\n'), extsource or "")
 
         if ui.verbose:
             fm.plain(_('  bundled: %s\n') % ['no', 'yes'][isinternal])
         fm.data(bundled=isinternal)
 
         fm.condwrite(ui.verbose and exttestedwith, 'testedwith',
                      _('  tested with: %s\n'),
                      fm.formatlist(exttestedwith, name='ver'))
 
         fm.condwrite(ui.verbose and extbuglink, 'buglink',
                  _('  bug reporting: %s\n'), extbuglink or "")
 
     fm.end()
 
 @command('debugfileset',
     [('r', 'rev', '', _('apply the filespec on this revision'), _('REV'))],
     _('[-r REV] FILESPEC'))
 def debugfileset(ui, repo, expr, **opts):
     '''parse and apply a fileset specification'''
     ctx = scmutil.revsingle(repo, opts.get(r'rev'), None)
     if ui.verbose:
         tree = fileset.parse(expr)
         ui.note(fileset.prettyformat(tree), "\n")
 
     for f in ctx.getfileset(expr):
         ui.write("%s\n" % f)
 
 @command('debugformat',
          [] + cmdutil.formatteropts,
         _(''))
 def debugformat(ui, repo, **opts):
     """display format information about the current repository
 
     Use --verbose to get extra information about current config value and
     Mercurial default."""
     opts = pycompat.byteskwargs(opts)
     maxvariantlength = max(len(fv.name) for fv in upgrade.allformatvariant)
     maxvariantlength = max(len('format-variant'), maxvariantlength)
 
     def makeformatname(name):
         return '%s:' + (' ' * (maxvariantlength - len(name)))
 
     fm = ui.formatter('debugformat', opts)
     if fm.isplain():
         def formatvalue(value):
             if util.safehasattr(value, 'startswith'):
                 return value
             if value:
                 return 'yes'
             else:
                 return 'no'
     else:
         formatvalue = pycompat.identity
 
     fm.plain('format-variant')
     fm.plain(' ' * (maxvariantlength - len('format-variant')))
     fm.plain(' repo')
     if ui.verbose:
         fm.plain(' config default')
     fm.plain('\n')
     for fv in upgrade.allformatvariant:
         fm.startitem()
         repovalue = fv.fromrepo(repo)
         configvalue = fv.fromconfig(repo)
 
         if repovalue != configvalue:
             namelabel = 'formatvariant.name.mismatchconfig'
             repolabel = 'formatvariant.repo.mismatchconfig'
         elif repovalue != fv.default:
             namelabel = 'formatvariant.name.mismatchdefault'
             repolabel = 'formatvariant.repo.mismatchdefault'
         else:
             namelabel = 'formatvariant.name.uptodate'
             repolabel = 'formatvariant.repo.uptodate'
 
         fm.write('name', makeformatname(fv.name), fv.name,
                  label=namelabel)
         fm.write('repo', ' %3s', formatvalue(repovalue),
                  label=repolabel)
         if fv.default != configvalue:
             configlabel = 'formatvariant.config.special'
         else:
             configlabel = 'formatvariant.config.default'
         fm.condwrite(ui.verbose, 'config', ' %6s', formatvalue(configvalue),
                      label=configlabel)
         fm.condwrite(ui.verbose, 'default', ' %7s', formatvalue(fv.default),
                      label='formatvariant.default')
         fm.plain('\n')
     fm.end()
 
 @command('debugfsinfo', [], _('[PATH]'), norepo=True)
 def debugfsinfo(ui, path="."):
     """show information detected about current filesystem"""
     ui.write(('path: %s\n') % path)
     ui.write(('mounted on: %s\n') % (util.getfsmountpoint(path) or '(unknown)'))
     ui.write(('exec: %s\n') % (util.checkexec(path) and 'yes' or 'no'))
     ui.write(('fstype: %s\n') % (util.getfstype(path) or '(unknown)'))
     ui.write(('symlink: %s\n') % (util.checklink(path) and 'yes' or 'no'))
     ui.write(('hardlink: %s\n') % (util.checknlink(path) and 'yes' or 'no'))
     casesensitive = '(unknown)'
     try:
         with tempfile.NamedTemporaryFile(prefix='.debugfsinfo', dir=path) as f:
             casesensitive = util.fscasesensitive(f.name) and 'yes' or 'no'
     except OSError:
         pass
     ui.write(('case-sensitive: %s\n') % casesensitive)
 
 @command('debuggetbundle',
     [('H', 'head', [], _('id of head node'), _('ID')),
     ('C', 'common', [], _('id of common node'), _('ID')),
     ('t', 'type', 'bzip2', _('bundle compression type to use'), _('TYPE'))],
     _('REPO FILE [-H|-C ID]...'),
     norepo=True)
 def debuggetbundle(ui, repopath, bundlepath, head=None, common=None, **opts):
     """retrieves a bundle from a repo
 
     Every ID must be a full-length hex node id string. Saves the bundle to the
     given file.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('getbundle'):
         raise error.Abort("getbundle() not supported by target repository")
     args = {}
     if common:
         args[r'common'] = [bin(s) for s in common]
     if head:
         args[r'heads'] = [bin(s) for s in head]
     # TODO: get desired bundlecaps from command line.
     args[r'bundlecaps'] = None
     bundle = repo.getbundle('debug', **args)
 
     bundletype = opts.get('type', 'bzip2').lower()
     btypes = {'none': 'HG10UN',
               'bzip2': 'HG10BZ',
               'gzip': 'HG10GZ',
               'bundle2': 'HG20'}
     bundletype = btypes.get(bundletype)
     if bundletype not in bundle2.bundletypes:
         raise error.Abort(_('unknown bundle type specified with --type'))
     bundle2.writebundle(ui, bundle, bundlepath, bundletype)
 
 @command('debugignore', [], '[FILE]')
 def debugignore(ui, repo, *files, **opts):
     """display the combined ignore pattern and information about ignored files
 
     With no argument display the combined ignore pattern.
 
     Given space separated file names, shows if the given file is ignored and
     if so, show the ignore rule (file and line number) that matched it.
     """
     ignore = repo.dirstate._ignore
     if not files:
         # Show all the patterns
         ui.write("%s\n" % pycompat.byterepr(ignore))
     else:
         m = scmutil.match(repo[None], pats=files)
         for f in m.files():
             nf = util.normpath(f)
             ignored = None
             ignoredata = None
             if nf != '.':
                 if ignore(nf):
                     ignored = nf
                     ignoredata = repo.dirstate._ignorefileandline(nf)
                 else:
                     for p in util.finddirs(nf):
                         if ignore(p):
                             ignored = p
                             ignoredata = repo.dirstate._ignorefileandline(p)
                             break
             if ignored:
                 if ignored == nf:
                     ui.write(_("%s is ignored\n") % m.uipath(f))
                 else:
                     ui.write(_("%s is ignored because of "
                                "containing folder %s\n")
                              % (m.uipath(f), ignored))
                 ignorefile, lineno, line = ignoredata
                 ui.write(_("(ignore rule in %s, line %d: '%s')\n")
                          % (ignorefile, lineno, line))
             else:
                 ui.write(_("%s is not ignored\n") % m.uipath(f))
 
 @command('debugindex', cmdutil.debugrevlogopts +
     [('f', 'format', 0, _('revlog format'), _('FORMAT'))],
     _('[-f FORMAT] -c|-m|FILE'),
     optionalrepo=True)
 def debugindex(ui, repo, file_=None, **opts):
     """dump the contents of an index file"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugindex', file_, opts)
     format = opts.get('format', 0)
     if format not in (0, 1):
         raise error.Abort(_("unknown format %d") % format)
 
     if ui.debugflag:
         shortfn = hex
     else:
         shortfn = short
 
     # There might not be anything in r, so have a sane default
     idlen = 12
     for i in r:
         idlen = len(shortfn(r.node(i)))
         break
 
     if format == 0:
+        if ui.verbose:
         ui.write(("   rev    offset  length linkrev"
-                 " %s %s p2\n") % ("nodeid".ljust(idlen), "p1".ljust(idlen)))
+                     " %s %s p2\n") % ("nodeid".ljust(idlen),
+                                       "p1".ljust(idlen)))
+        else:
+            ui.write(("   rev linkrev %s %s p2\n") % (
+                "nodeid".ljust(idlen), "p1".ljust(idlen)))
     elif format == 1:
-        ui.write(("   rev flag   offset   length     size   link     p1     p2"
-                 " %s\n") % "nodeid".rjust(idlen))
+        if ui.verbose:
+            ui.write(("   rev flag   offset   length     size   link     p1"
+                      "     p2 %s\n") % "nodeid".rjust(idlen))
+        else:
+            ui.write(("   rev flag     size   link     p1     p2 %s\n") %
+                     "nodeid".rjust(idlen))
 
     for i in r:
         node = r.node(i)
         if format == 0:
             try:
                 pp = r.parents(node)
             except Exception:
                 pp = [nullid, nullid]
+            if ui.verbose:
             ui.write("% 6d % 9d % 7d % 7d %s %s %s\n" % (
                     i, r.start(i), r.length(i), r.linkrev(i),
                     shortfn(node), shortfn(pp[0]), shortfn(pp[1])))
+            else:
+                ui.write("% 6d % 7d %s %s %s\n" % (
+                    i, r.linkrev(i), shortfn(node), shortfn(pp[0]),
+                    shortfn(pp[1])))
         elif format == 1:
             pr = r.parentrevs(i)
+            if ui.verbose:
             ui.write("% 6d %04x % 8d % 8d % 8d % 6d % 6d % 6d %s\n" % (
                     i, r.flags(i), r.start(i), r.length(i), r.rawsize(i),
                     r.linkrev(i), pr[0], pr[1], shortfn(node)))
+            else:
+                ui.write("% 6d %04x % 8d % 6d % 6d % 6d %s\n" % (
+                    i, r.flags(i), r.rawsize(i), r.linkrev(i), pr[0], pr[1],
+                    shortfn(node)))
 
 @command('debugindexdot', cmdutil.debugrevlogopts,
     _('-c|-m|FILE'), optionalrepo=True)
 def debugindexdot(ui, repo, file_=None, **opts):
     """dump an index DAG as a graphviz dot file"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugindexdot', file_, opts)
     ui.write(("digraph G {\n"))
     for i in r:
         node = r.node(i)
         pp = r.parents(node)
         ui.write("\t%d -> %d\n" % (r.rev(pp[0]), i))
         if pp[1] != nullid:
             ui.write("\t%d -> %d\n" % (r.rev(pp[1]), i))
     ui.write("}\n")
 
 @command('debuginstall', [] + cmdutil.formatteropts, '', norepo=True)
 def debuginstall(ui, **opts):
     '''test Mercurial installation
 
     Returns 0 on success.
     '''
     opts = pycompat.byteskwargs(opts)
 
     def writetemp(contents):
         (fd, name) = tempfile.mkstemp(prefix="hg-debuginstall-")
         f = os.fdopen(fd, r"wb")
         f.write(contents)
         f.close()
         return name
 
     problems = 0
 
     fm = ui.formatter('debuginstall', opts)
     fm.startitem()
 
     # encoding
     fm.write('encoding', _("checking encoding (%s)...\n"), encoding.encoding)
     err = None
     try:
         codecs.lookup(pycompat.sysstr(encoding.encoding))
     except LookupError as inst:
         err = stringutil.forcebytestr(inst)
         problems += 1
     fm.condwrite(err, 'encodingerror', _(" %s\n"
                  " (check that your locale is properly set)\n"), err)
 
     # Python
     fm.write('pythonexe', _("checking Python executable (%s)\n"),
              pycompat.sysexecutable)
     fm.write('pythonver', _("checking Python version (%s)\n"),
              ("%d.%d.%d" % sys.version_info[:3]))
     fm.write('pythonlib', _("checking Python lib (%s)...\n"),
              os.path.dirname(pycompat.fsencode(os.__file__)))
 
     security = set(sslutil.supportedprotocols)
     if sslutil.hassni:
         security.add('sni')
 
     fm.write('pythonsecurity', _("checking Python security support (%s)\n"),
              fm.formatlist(sorted(security), name='protocol',
                            fmt='%s', sep=','))
 
     # These are warnings, not errors. So don't increment problem count. This
     # may change in the future.
     if 'tls1.2' not in security:
         fm.plain(_('  TLS 1.2 not supported by Python install; '
                    'network connections lack modern security\n'))
     if 'sni' not in security:
         fm.plain(_('  SNI not supported by Python install; may have '
                    'connectivity issues with some servers\n'))
 
     # TODO print CA cert info
 
     # hg version
     hgver = util.version()
     fm.write('hgver', _("checking Mercurial version (%s)\n"),
              hgver.split('+')[0])
     fm.write('hgverextra', _("checking Mercurial custom build (%s)\n"),
              '+'.join(hgver.split('+')[1:]))
 
     # compiled modules
     fm.write('hgmodulepolicy', _("checking module policy (%s)\n"),
              policy.policy)
     fm.write('hgmodules', _("checking installed modules (%s)...\n"),
              os.path.dirname(pycompat.fsencode(__file__)))
 
     if policy.policy in ('c', 'allow'):
         err = None
         try:
             from .cext import (
                 base85,
                 bdiff,
                 mpatch,
                 osutil,
             )
             dir(bdiff), dir(mpatch), dir(base85), dir(osutil) # quiet pyflakes
         except Exception as inst:
             err = stringutil.forcebytestr(inst)
             problems += 1
         fm.condwrite(err, 'extensionserror', " %s\n", err)
 
     compengines = util.compengines._engines.values()
     fm.write('compengines', _('checking registered compression engines (%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines),
                            name='compengine', fmt='%s', sep=', '))
     fm.write('compenginesavail', _('checking available compression engines '
                                    '(%s)\n'),
              fm.formatlist(sorted(e.name() for e in compengines
                                   if e.available()),
                            name='compengine', fmt='%s', sep=', '))
     wirecompengines = util.compengines.supportedwireengines(util.SERVERROLE)
     fm.write('compenginesserver', _('checking available compression engines '
                                     'for wire protocol (%s)\n'),
              fm.formatlist([e.name() for e in wirecompengines
                             if e.wireprotosupport()],
                            name='compengine', fmt='%s', sep=', '))
     re2 = 'missing'
     if util._re2:
         re2 = 'available'
     fm.plain(_('checking "re2" regexp engine (%s)\n') % re2)
     fm.data(re2=bool(util._re2))
 
     # templates
     p = templater.templatepaths()
     fm.write('templatedirs', 'checking templates (%s)...\n', ' '.join(p))
     fm.condwrite(not p, '', _(" no template directories found\n"))
     if p:
         m = templater.templatepath("map-cmdline.default")
         if m:
             # template found, check if it is working
             err = None
             try:
                 templater.templater.frommapfile(m)
             except Exception as inst:
                 err = stringutil.forcebytestr(inst)
                 p = None
             fm.condwrite(err, 'defaulttemplateerror', " %s\n", err)
         else:
             p = None
         fm.condwrite(p, 'defaulttemplate',
                      _("checking default template (%s)\n"), m)
         fm.condwrite(not m, 'defaulttemplatenotfound',
                      _(" template '%s' not found\n"), "default")
     if not p:
         problems += 1
     fm.condwrite(not p, '',
                  _(" (templates seem to have been installed incorrectly)\n"))
 
     # editor
     editor = ui.geteditor()
     editor = util.expandpath(editor)
     editorbin = procutil.shellsplit(editor)[0]
     fm.write('editor', _("checking commit editor... (%s)\n"), editorbin)
     cmdpath = procutil.findexe(editorbin)
     fm.condwrite(not cmdpath and editor == 'vi', 'vinotfound',
                  _(" No commit editor set and can't find %s in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editor == 'vi' and editorbin)
     fm.condwrite(not cmdpath and editor != 'vi', 'editornotfound',
                  _(" Can't find editor '%s' in PATH\n"
                    " (specify a commit editor in your configuration"
                    " file)\n"), not cmdpath and editorbin)
     if not cmdpath and editor != 'vi':
         problems += 1
 
     # check username
     username = None
     err = None
     try:
         username = ui.username()
     except error.Abort as e:
         err = stringutil.forcebytestr(e)
         problems += 1
 
     fm.condwrite(username, 'username',  _("checking username (%s)\n"), username)
     fm.condwrite(err, 'usernameerror', _("checking username...\n %s\n"
         " (specify a username in your configuration file)\n"), err)
 
     fm.condwrite(not problems, '',
                  _("no problems detected\n"))
     if not problems:
         fm.data(problems=problems)
     fm.condwrite(problems, 'problems',
                  _("%d problems detected,"
                    " please check your install!\n"), problems)
     fm.end()
 
     return problems
 
 @command('debugknown', [], _('REPO ID...'), norepo=True)
 def debugknown(ui, repopath, *ids, **opts):
     """test whether node ids are known to a repo
 
     Every ID must be a full-length hex node id string. Returns a list of 0s
     and 1s indicating unknown/known.
     """
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     if not repo.capable('known'):
         raise error.Abort("known() not supported by target repository")
     flags = repo.known([bin(s) for s in ids])
     ui.write("%s\n" % ("".join([f and "1" or "0" for f in flags])))
 
 @command('debuglabelcomplete', [], _('LABEL...'))
 def debuglabelcomplete(ui, repo, *args):
     '''backwards compatibility with old bash completion scripts (DEPRECATED)'''
     debugnamecomplete(ui, repo, *args)
 
 @command('debuglocks',
          [('L', 'force-lock', None, _('free the store lock (DANGEROUS)')),
           ('W', 'force-wlock', None,
            _('free the working state lock (DANGEROUS)')),
           ('s', 'set-lock', None, _('set the store lock until stopped')),
           ('S', 'set-wlock', None,
            _('set the working state lock until stopped'))],
          _('[OPTION]...'))
 def debuglocks(ui, repo, **opts):
     """show or modify state of locks
 
     By default, this command will show which locks are held. This
     includes the user and process holding the lock, the amount of time
     the lock has been held, and the machine name where the process is
     running if it's not local.
 
     Locks protect the integrity of Mercurial's data, so should be
     treated with care. System crashes or other interruptions may cause
     locks to not be properly released, though Mercurial will usually
     detect and remove such stale locks automatically.
 
     However, detecting stale locks may not always be possible (for
     instance, on a shared filesystem). Removing locks may also be
     blocked by filesystem permissions.
 
     Setting a lock will prevent other commands from changing the data.
     The command will wait until an interruption (SIGINT, SIGTERM, ...) occurs.
     The set locks are removed when the command exits.
 
     Returns 0 if no locks are held.
 
     """
 
     if opts.get(r'force_lock'):
         repo.svfs.unlink('lock')
     if opts.get(r'force_wlock'):
         repo.vfs.unlink('wlock')
     if opts.get(r'force_lock') or opts.get(r'force_wlock'):
         return 0
 
     locks = []
     try:
         if opts.get(r'set_wlock'):
             try:
                 locks.append(repo.wlock(False))
             except error.LockHeld:
                 raise error.Abort(_('wlock is already held'))
         if opts.get(r'set_lock'):
             try:
                 locks.append(repo.lock(False))
             except error.LockHeld:
                 raise error.Abort(_('lock is already held'))
         if len(locks):
             ui.promptchoice(_("ready to release the lock (y)? $$ &Yes"))
             return 0
     finally:
         release(*locks)
 
     now = time.time()
     held = 0
 
     def report(vfs, name, method):
         # this causes stale locks to get reaped for more accurate reporting
         try:
             l = method(False)
         except error.LockHeld:
             l = None
 
         if l:
             l.release()
         else:
             try:
                 st = vfs.lstat(name)
                 age = now - st[stat.ST_MTIME]
                 user = util.username(st.st_uid)
                 locker = vfs.readlock(name)
                 if ":" in locker:
                     host, pid = locker.split(':')
                     if host == socket.gethostname():
                         locker = 'user %s, process %s' % (user, pid)
                     else:
                         locker = 'user %s, process %s, host %s' \
                                  % (user, pid, host)
                 ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age))
                 return 1
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
 
         ui.write(("%-6s free\n") % (name + ":"))
         return 0
 
     held += report(repo.svfs, "lock", repo.lock)
     held += report(repo.vfs, "wlock", repo.wlock)
 
     return held
 
 @command('debugmergestate', [], '')
 def debugmergestate(ui, repo, *args):
     """print merge state
 
     Use --verbose to print out information about whether v1 or v2 merge state
     was chosen."""
     def _hashornull(h):
         if h == nullhex:
             return 'null'
         else:
             return h
 
     def printrecords(version):
         ui.write(('* version %d records\n') % version)
         if version == 1:
             records = v1records
         else:
             records = v2records
 
         for rtype, record in records:
             # pretty print some record types
             if rtype == 'L':
                 ui.write(('local: %s\n') % record)
             elif rtype == 'O':
                 ui.write(('other: %s\n') % record)
             elif rtype == 'm':
                 driver, mdstate = record.split('\0', 1)
                 ui.write(('merge driver: %s (state "%s")\n')
                          % (driver, mdstate))
             elif rtype in 'FDC':
                 r = record.split('\0')
                 f, state, hash, lfile, afile, anode, ofile = r[0:7]
                 if version == 1:
                     onode = 'not stored in v1 format'
                     flags = r[7]
                 else:
                     onode, flags = r[7:9]
                 ui.write(('file: %s (record type "%s", state "%s", hash %s)\n')
                          % (f, rtype, state, _hashornull(hash)))
                 ui.write(('  local path: %s (flags "%s")\n') % (lfile, flags))
                 ui.write(('  ancestor path: %s (node %s)\n')
                          % (afile, _hashornull(anode)))
                 ui.write(('  other path: %s (node %s)\n')
                          % (ofile, _hashornull(onode)))
             elif rtype == 'f':
                 filename, rawextras = record.split('\0', 1)
                 extras = rawextras.split('\0')
                 i = 0
                 extrastrings = []
                 while i < len(extras):
                     extrastrings.append('%s = %s' % (extras[i], extras[i + 1]))
                     i += 2
 
                 ui.write(('file extras: %s (%s)\n')
                          % (filename, ', '.join(extrastrings)))
             elif rtype == 'l':
                 labels = record.split('\0', 2)
                 labels = [l for l in labels if len(l) > 0]
                 ui.write(('labels:\n'))
                 ui.write(('  local: %s\n' % labels[0]))
                 ui.write(('  other: %s\n' % labels[1]))
                 if len(labels) > 2:
                     ui.write(('  base:  %s\n' % labels[2]))
             else:
                 ui.write(('unrecognized entry: %s\t%s\n')
                          % (rtype, record.replace('\0', '\t')))
 
     # Avoid mergestate.read() since it may raise an exception for unsupported
     # merge state records. We shouldn't be doing this, but this is OK since this
     # command is pretty low-level.
     ms = mergemod.mergestate(repo)
 
     # sort so that reasonable information is on top
     v1records = ms._readrecordsv1()
     v2records = ms._readrecordsv2()
     order = 'LOml'
     def key(r):
         idx = order.find(r[0])
         if idx == -1:
             return (1, r[1])
         else:
             return (0, idx)
     v1records.sort(key=key)
     v2records.sort(key=key)
 
     if not v1records and not v2records:
         ui.write(('no merge state found\n'))
     elif not v2records:
         ui.note(('no version 2 merge state\n'))
         printrecords(1)
     elif ms._v1v2match(v1records, v2records):
         ui.note(('v1 and v2 states match: using v2\n'))
         printrecords(2)
     else:
         ui.note(('v1 and v2 states mismatch: using v1\n'))
         printrecords(1)
         if ui.verbose:
             printrecords(2)
 
 @command('debugnamecomplete', [], _('NAME...'))
 def debugnamecomplete(ui, repo, *args):
     '''complete "names" - tags, open branch names, bookmark names'''
 
     names = set()
     # since we previously only listed open branches, we will handle that
     # specially (after this for loop)
     for name, ns in repo.names.iteritems():
         if name != 'branches':
             names.update(ns.listnames(repo))
     names.update(tag for (tag, heads, tip, closed)
                  in repo.branchmap().iterbranches() if not closed)
     completions = set()
     if not args:
         args = ['']
     for a in args:
         completions.update(n for n in names if n.startswith(a))
     ui.write('\n'.join(sorted(completions)))
     ui.write('\n')
 
 @command('debugobsolete',
         [('', 'flags', 0, _('markers flag')),
          ('', 'record-parents', False,
           _('record parent information for the precursor')),
          ('r', 'rev', [], _('display markers relevant to REV')),
          ('', 'exclusive', False, _('restrict display to markers only '
                                     'relevant to REV')),
          ('', 'index', False, _('display index of the marker')),
          ('', 'delete', [], _('delete markers specified by indices')),
         ] + cmdutil.commitopts2 + cmdutil.formatteropts,
          _('[OBSOLETED [REPLACEMENT ...]]'))
 def debugobsolete(ui, repo, precursor=None, *successors, **opts):
     """create arbitrary obsolete marker
 
     With no arguments, displays the list of obsolescence markers."""
 
     opts = pycompat.byteskwargs(opts)
 
     def parsenodeid(s):
         try:
             # We do not use revsingle/revrange functions here to accept
             # arbitrary node identifiers, possibly not present in the
             # local repository.
             n = bin(s)
             if len(n) != len(nullid):
                 raise TypeError()
             return n
         except TypeError:
             raise error.Abort('changeset references must be full hexadecimal '
                              'node identifiers')
 
     if opts.get('delete'):
         indices = []
         for v in opts.get('delete'):
             try:
                 indices.append(int(v))
             except ValueError:
                 raise error.Abort(_('invalid index value: %r') % v,
                                   hint=_('use integers for indices'))
 
         if repo.currenttransaction():
             raise error.Abort(_('cannot delete obsmarkers in the middle '
                                 'of transaction.'))
 
         with repo.lock():
             n = repair.deleteobsmarkers(repo.obsstore, indices)
             ui.write(_('deleted %i obsolescence markers\n') % n)
 
         return
 
     if precursor is not None:
         if opts['rev']:
             raise error.Abort('cannot select revision when creating marker')
         metadata = {}
         metadata['user'] = opts['user'] or ui.username()
         succs = tuple(parsenodeid(succ) for succ in successors)
         l = repo.lock()
         try:
             tr = repo.transaction('debugobsolete')
             try:
                 date = opts.get('date')
                 if date:
                     date = dateutil.parsedate(date)
                 else:
                     date = None
                 prec = parsenodeid(precursor)
                 parents = None
                 if opts['record_parents']:
                     if prec not in repo.unfiltered():
                         raise error.Abort('cannot used --record-parents on '
                                          'unknown changesets')
                     parents = repo.unfiltered()[prec].parents()
                     parents = tuple(p.node() for p in parents)
                 repo.obsstore.create(tr, prec, succs, opts['flags'],
                                      parents=parents, date=date,
                                      metadata=metadata, ui=ui)
                 tr.close()
             except ValueError as exc:
                 raise error.Abort(_('bad obsmarker input: %s') %
                                   pycompat.bytestr(exc))
             finally:
                 tr.release()
         finally:
             l.release()
     else:
         if opts['rev']:
             revs = scmutil.revrange(repo, opts['rev'])
             nodes = [repo[r].node() for r in revs]
             markers = list(obsutil.getmarkers(repo, nodes=nodes,
                                                exclusive=opts['exclusive']))
             markers.sort(key=lambda x: x._data)
         else:
             markers = obsutil.getmarkers(repo)
 
         markerstoiter = markers
         isrelevant = lambda m: True
         if opts.get('rev') and opts.get('index'):
             markerstoiter = obsutil.getmarkers(repo)
             markerset = set(markers)
             isrelevant = lambda m: m in markerset
 
         fm = ui.formatter('debugobsolete', opts)
         for i, m in enumerate(markerstoiter):
             if not isrelevant(m):
                 # marker can be irrelevant when we're iterating over a set
                 # of markers (markerstoiter) which is bigger than the set
                 # of markers we want to display (markers)
                 # this can happen if both --index and --rev options are
                 # provided and thus we need to iterate over all of the markers
                 # to get the correct indices, but only display the ones that
                 # are relevant to --rev value
                 continue
             fm.startitem()
             ind = i if opts.get('index') else None
             cmdutil.showmarker(fm, m, index=ind)
         fm.end()
 
 @command('debugpathcomplete',
          [('f', 'full', None, _('complete an entire path')),
           ('n', 'normal', None, _('show only normal files')),
           ('a', 'added', None, _('show only added files')),
           ('r', 'removed', None, _('show only removed files'))],
          _('FILESPEC...'))
 def debugpathcomplete(ui, repo, *specs, **opts):
     '''complete part or all of a tracked path
 
     This command supports shells that offer path name completion. It
     currently completes only files already known to the dirstate.
 
     Completion extends only to the next path segment unless
     --full is specified, in which case entire paths are used.'''
 
     def complete(path, acceptable):
         dirstate = repo.dirstate
         spec = os.path.normpath(os.path.join(pycompat.getcwd(), path))
         rootdir = repo.root + pycompat.ossep
         if spec != repo.root and not spec.startswith(rootdir):
             return [], []
         if os.path.isdir(spec):
             spec += '/'
         spec = spec[len(rootdir):]
         fixpaths = pycompat.ossep != '/'
         if fixpaths:
             spec = spec.replace(pycompat.ossep, '/')
         speclen = len(spec)
         fullpaths = opts[r'full']
         files, dirs = set(), set()
         adddir, addfile = dirs.add, files.add
         for f, st in dirstate.iteritems():
             if f.startswith(spec) and st[0] in acceptable:
                 if fixpaths:
                     f = f.replace('/', pycompat.ossep)
                 if fullpaths:
                     addfile(f)
                     continue
                 s = f.find(pycompat.ossep, speclen)
                 if s >= 0:
                     adddir(f[:s])
                 else:
                     addfile(f)
         return files, dirs
 
     acceptable = ''
     if opts[r'normal']:
         acceptable += 'nm'
     if opts[r'added']:
         acceptable += 'a'
     if opts[r'removed']:
         acceptable += 'r'
     cwd = repo.getcwd()
     if not specs:
         specs = ['.']
 
     files, dirs = set(), set()
     for spec in specs:
         f, d = complete(spec, acceptable or 'nmar')
         files.update(f)
         dirs.update(d)
     files.update(dirs)
     ui.write('\n'.join(repo.pathto(p, cwd) for p in sorted(files)))
     ui.write('\n')
 
 @command('debugpeer', [], _('PATH'), norepo=True)
 def debugpeer(ui, path):
     """establish a connection to a peer repository"""
     # Always enable peer request logging. Requires --debug to display
     # though.
     overrides = {
         ('devel', 'debug.peer-request'): True,
     }
 
     with ui.configoverride(overrides):
         peer = hg.peer(ui, {}, path)
 
         local = peer.local() is not None
         canpush = peer.canpush()
 
         ui.write(_('url: %s\n') % peer.url())
         ui.write(_('local: %s\n') % (_('yes') if local else _('no')))
         ui.write(_('pushable: %s\n') % (_('yes') if canpush else _('no')))
 
 @command('debugpickmergetool',
         [('r', 'rev', '', _('check for files in this revision'), _('REV')),
          ('', 'changedelete', None, _('emulate merging change and delete')),
         ] + cmdutil.walkopts + cmdutil.mergetoolopts,
         _('[PATTERN]...'),
         inferrepo=True)
 def debugpickmergetool(ui, repo, *pats, **opts):
     """examine which merge tool is chosen for specified file
 
     As described in :hg:`help merge-tools`, Mercurial examines
     configurations below in this order to decide which merge tool is
     chosen for specified file.
 
     1. ``--tool`` option
     2. ``HGMERGE`` environment variable
     3. configurations in ``merge-patterns`` section
     4. configuration of ``ui.merge``
     5. configurations in ``merge-tools`` section
     6. ``hgmerge`` tool (for historical reason only)
     7. default tool for fallback (``:merge`` or ``:prompt``)
 
     This command writes out examination result in the style below::
 
         FILE = MERGETOOL
 
     By default, all files known in the first parent context of the
     working directory are examined. Use file patterns and/or -I/-X
     options to limit target files. -r/--rev is also useful to examine
     files in another context without actual updating to it.
 
     With --debug, this command shows warning messages while matching
     against ``merge-patterns`` and so on, too. It is recommended to
     use this option with explicit file patterns and/or -I/-X options,
     because this option increases amount of output per file according
     to configurations in hgrc.
 
     With -v/--verbose, this command shows configurations below at
     first (only if specified).
 
     - ``--tool`` option
     - ``HGMERGE`` environment variable
     - configuration of ``ui.merge``
 
     If merge tool is chosen before matching against
     ``merge-patterns``, this command can't show any helpful
     information, even with --debug. In such case, information above is
     useful to know why a merge tool is chosen.
     """
     opts = pycompat.byteskwargs(opts)
     overrides = {}
     if opts['tool']:
         overrides[('ui', 'forcemerge')] = opts['tool']
         ui.note(('with --tool %r\n') % (pycompat.bytestr(opts['tool'])))
 
     with ui.configoverride(overrides, 'debugmergepatterns'):
         hgmerge = encoding.environ.get("HGMERGE")
         if hgmerge is not None:
             ui.note(('with HGMERGE=%r\n') % (pycompat.bytestr(hgmerge)))
         uimerge = ui.config("ui", "merge")
         if uimerge:
             ui.note(('with ui.merge=%r\n') % (pycompat.bytestr(uimerge)))
 
         ctx = scmutil.revsingle(repo, opts.get('rev'))
         m = scmutil.match(ctx, pats, opts)
         changedelete = opts['changedelete']
         for path in ctx.walk(m):
             fctx = ctx[path]
             try:
                 if not ui.debugflag:
                     ui.pushbuffer(error=True)
                 tool, toolpath = filemerge._picktool(repo, ui, path,
                                                      fctx.isbinary(),
                                                      'l' in fctx.flags(),
                                                      changedelete)
             finally:
                 if not ui.debugflag:
                     ui.popbuffer()
             ui.write(('%s = %s\n') % (path, tool))
 
 @command('debugpushkey', [], _('REPO NAMESPACE [KEY OLD NEW]'), norepo=True)
 def debugpushkey(ui, repopath, namespace, *keyinfo, **opts):
     '''access the pushkey key/value protocol
 
     With two args, list the keys in the given namespace.
 
     With five args, set a key to new if it currently is set to old.
     Reports success or failure.
     '''
 
     target = hg.peer(ui, {}, repopath)
     if keyinfo:
         key, old, new = keyinfo
         r = target.pushkey(namespace, key, old, new)
         ui.status(pycompat.bytestr(r) + '\n')
         return not r
     else:
         for k, v in sorted(target.listkeys(namespace).iteritems()):
             ui.write("%s\t%s\n" % (stringutil.escapestr(k),
                                    stringutil.escapestr(v)))
 
 @command('debugpvec', [], _('A B'))
 def debugpvec(ui, repo, a, b=None):
     ca = scmutil.revsingle(repo, a)
     cb = scmutil.revsingle(repo, b)
     pa = pvec.ctxpvec(ca)
     pb = pvec.ctxpvec(cb)
     if pa == pb:
         rel = "="
     elif pa > pb:
         rel = ">"
     elif pa < pb:
         rel = "<"
     elif pa | pb:
         rel = "|"
     ui.write(_("a: %s\n") % pa)
     ui.write(_("b: %s\n") % pb)
     ui.write(_("depth(a): %d depth(b): %d\n") % (pa._depth, pb._depth))
     ui.write(_("delta: %d hdist: %d distance: %d relation: %s\n") %
              (abs(pa._depth - pb._depth), pvec._hamming(pa._vec, pb._vec),
               pa.distance(pb), rel))
 
 @command('debugrebuilddirstate|debugrebuildstate',
     [('r', 'rev', '', _('revision to rebuild to'), _('REV')),
      ('', 'minimal', None, _('only rebuild files that are inconsistent with '
                              'the working copy parent')),
     ],
     _('[-r REV]'))
 def debugrebuilddirstate(ui, repo, rev, **opts):
     """rebuild the dirstate as it would look like for the given revision
 
     If no revision is specified the first current parent will be used.
 
     The dirstate will be set to the files of the given revision.
     The actual working directory content or existing dirstate
     information such as adds or removes is not considered.
 
     ``minimal`` will only rebuild the dirstate status for files that claim to be
     tracked but are not in the parent manifest, or that exist in the parent
     manifest but are not in the dirstate. It will not change adds, removes, or
     modified files that are in the working copy parent.
 
     One use of this command is to make the next :hg:`status` invocation
     check the actual file content.
     """
     ctx = scmutil.revsingle(repo, rev)
     with repo.wlock():
         dirstate = repo.dirstate
         changedfiles = None
         # See command doc for what minimal does.
         if opts.get(r'minimal'):
             manifestfiles = set(ctx.manifest().keys())
             dirstatefiles = set(dirstate)
             manifestonly = manifestfiles - dirstatefiles
             dsonly = dirstatefiles - manifestfiles
             dsnotadded = set(f for f in dsonly if dirstate[f] != 'a')
             changedfiles = manifestonly | dsnotadded
 
         dirstate.rebuild(ctx.node(), ctx.manifest(), changedfiles)
 
 @command('debugrebuildfncache', [], '')
 def debugrebuildfncache(ui, repo):
     """rebuild the fncache file"""
     repair.rebuildfncache(ui, repo)
 
 @command('debugrename',
     [('r', 'rev', '', _('revision to debug'), _('REV'))],
     _('[-r REV] FILE'))
 def debugrename(ui, repo, file1, *pats, **opts):
     """dump rename information"""
 
     opts = pycompat.byteskwargs(opts)
     ctx = scmutil.revsingle(repo, opts.get('rev'))
     m = scmutil.match(ctx, (file1,) + pats, opts)
     for abs in ctx.walk(m):
         fctx = ctx[abs]
         o = fctx.filelog().renamed(fctx.filenode())
         rel = m.rel(abs)
         if o:
             ui.write(_("%s renamed from %s:%s\n") % (rel, o[0], hex(o[1])))
         else:
             ui.write(_("%s not renamed\n") % rel)
 
 @command('debugrevlog', cmdutil.debugrevlogopts +
     [('d', 'dump', False, _('dump index data'))],
     _('-c|-m|FILE'),
     optionalrepo=True)
 def debugrevlog(ui, repo, file_=None, **opts):
     """show data and statistics about a revlog"""
     opts = pycompat.byteskwargs(opts)
     r = cmdutil.openrevlog(repo, 'debugrevlog', file_, opts)
 
     if opts.get("dump"):
         numrevs = len(r)
         ui.write(("# rev p1rev p2rev start   end deltastart base   p1   p2"
                  " rawsize totalsize compression heads chainlen\n"))
         ts = 0
         heads = set()
 
         for rev in xrange(numrevs):
             dbase = r.deltaparent(rev)
             if dbase == -1:
                 dbase = rev
             cbase = r.chainbase(rev)
             clen = r.chainlen(rev)
             p1, p2 = r.parentrevs(rev)
             rs = r.rawsize(rev)
             ts = ts + rs
             heads -= set(r.parentrevs(rev))
             heads.add(rev)
             try:
                 compression = ts / r.end(rev)
             except ZeroDivisionError:
                 compression = 0
             ui.write("%5d %5d %5d %5d %5d %10d %4d %4d %4d %7d %9d "
                      "%11d %5d %8d\n" %
                      (rev, p1, p2, r.start(rev), r.end(rev),
                       r.start(dbase), r.start(cbase),
                       r.start(p1), r.start(p2),
                       rs, ts, compression, len(heads), clen))
         return 0
 
     v = r.version
     format = v & 0xFFFF
     flags = []
     gdelta = False
     if v & revlog.FLAG_INLINE_DATA:
         flags.append('inline')
     if v & revlog.FLAG_GENERALDELTA:
         gdelta = True
         flags.append('generaldelta')
     if not flags:
         flags = ['(none)']
 
     nummerges = 0
     numfull = 0
     numprev = 0
     nump1 = 0
     nump2 = 0
     numother = 0
     nump1prev = 0
     nump2prev = 0
     chainlengths = []
     chainbases = []
     chainspans = []
 
     datasize = [None, 0, 0]
     fullsize = [None, 0, 0]
     deltasize = [None, 0, 0]
     chunktypecounts = {}
     chunktypesizes = {}
 
     def addsize(size, l):
         if l[0] is None or size < l[0]:
             l[0] = size
         if size > l[1]:
             l[1] = size
         l[2] += size
 
     numrevs = len(r)
     for rev in xrange(numrevs):
         p1, p2 = r.parentrevs(rev)
         delta = r.deltaparent(rev)
         if format > 0:
             addsize(r.rawsize(rev), datasize)
         if p2 != nullrev:
             nummerges += 1
         size = r.length(rev)
         if delta == nullrev:
             chainlengths.append(0)
             chainbases.append(r.start(rev))
             chainspans.append(size)
             numfull += 1
             addsize(size, fullsize)
         else:
             chainlengths.append(chainlengths[delta] + 1)
             baseaddr = chainbases[delta]
             revaddr = r.start(rev)
             chainbases.append(baseaddr)
             chainspans.append((revaddr - baseaddr) + size)
             addsize(size, deltasize)
             if delta == rev - 1:
                 numprev += 1
                 if delta == p1:
                     nump1prev += 1
                 elif delta == p2:
                     nump2prev += 1
             elif delta == p1:
                 nump1 += 1
             elif delta == p2:
                 nump2 += 1
             elif delta != nullrev:
                 numother += 1
 
         # Obtain data on the raw chunks in the revlog.
         segment = r._getsegmentforrevs(rev, rev)[1]
         if segment:
             chunktype = bytes(segment[0:1])
         else:
             chunktype = 'empty'
 
         if chunktype not in chunktypecounts:
             chunktypecounts[chunktype] = 0
             chunktypesizes[chunktype] = 0
 
         chunktypecounts[chunktype] += 1
         chunktypesizes[chunktype] += size
 
     # Adjust size min value for empty cases
     for size in (datasize, fullsize, deltasize):
         if size[0] is None:
             size[0] = 0
 
     numdeltas = numrevs - numfull
     numoprev = numprev - nump1prev - nump2prev
     totalrawsize = datasize[2]
     datasize[2] /= numrevs
     fulltotal = fullsize[2]
     fullsize[2] /= numfull
     deltatotal = deltasize[2]
     if numrevs - numfull > 0:
         deltasize[2] /= numrevs - numfull
     totalsize = fulltotal + deltatotal
     avgchainlen = sum(chainlengths) / numrevs
     maxchainlen = max(chainlengths)
     maxchainspan = max(chainspans)
     compratio = 1
     if totalsize:
         compratio = totalrawsize / totalsize
 
     basedfmtstr = '%%%dd\n'
     basepcfmtstr = '%%%dd %s(%%5.2f%%%%)\n'
 
     def dfmtstr(max):
         return basedfmtstr % len(str(max))
     def pcfmtstr(max, padding=0):
         return basepcfmtstr % (len(str(max)), ' ' * padding)
 
     def pcfmt(value, total):
         if total:
             return (value, 100 * float(value) / total)
         else:
             return value, 100.0
 
     ui.write(('format : %d\n') % format)
     ui.write(('flags  : %s\n') % ', '.join(flags))
 
     ui.write('\n')
     fmt = pcfmtstr(totalsize)
     fmt2 = dfmtstr(totalsize)
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    merges    : ') + fmt % pcfmt(nummerges, numrevs))
     ui.write(('    normal    : ') + fmt % pcfmt(numrevs - nummerges, numrevs))
     ui.write(('revisions     : ') + fmt2 % numrevs)
     ui.write(('    full      : ') + fmt % pcfmt(numfull, numrevs))
     ui.write(('    deltas    : ') + fmt % pcfmt(numdeltas, numrevs))
     ui.write(('revision size : ') + fmt2 % totalsize)
     ui.write(('    full      : ') + fmt % pcfmt(fulltotal, totalsize))
     ui.write(('    deltas    : ') + fmt % pcfmt(deltatotal, totalsize))
 
     def fmtchunktype(chunktype):
         if chunktype == 'empty':
             return '    %s     : ' % chunktype
         elif chunktype in pycompat.bytestr(string.ascii_letters):
             return '    0x%s (%s)  : ' % (hex(chunktype), chunktype)
         else:
             return '    0x%s      : ' % hex(chunktype)
 
     ui.write('\n')
     ui.write(('chunks        : ') + fmt2 % numrevs)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypecounts[chunktype], numrevs))
     ui.write(('chunks size   : ') + fmt2 % totalsize)
     for chunktype in sorted(chunktypecounts):
         ui.write(fmtchunktype(chunktype))
         ui.write(fmt % pcfmt(chunktypesizes[chunktype], totalsize))
 
     ui.write('\n')
     fmt = dfmtstr(max(avgchainlen, maxchainlen, maxchainspan, compratio))
     ui.write(('avg chain length  : ') + fmt % avgchainlen)
     ui.write(('max chain length  : ') + fmt % maxchainlen)
     ui.write(('max chain reach   : ') + fmt % maxchainspan)
     ui.write(('compression ratio : ') + fmt % compratio)
 
     if format > 0:
         ui.write('\n')
         ui.write(('uncompressed data size (min/max/avg) : %d / %d / %d\n')
                  % tuple(datasize))
     ui.write(('full revision size (min/max/avg)     : %d / %d / %d\n')
              % tuple(fullsize))
     ui.write(('delta size (min/max/avg)             : %d / %d / %d\n')
              % tuple(deltasize))
 
     if numdeltas > 0:
         ui.write('\n')
         fmt = pcfmtstr(numdeltas)
         fmt2 = pcfmtstr(numdeltas, 4)
         ui.write(('deltas against prev  : ') + fmt % pcfmt(numprev, numdeltas))
         if numprev > 0:
             ui.write(('    where prev = p1  : ') + fmt2 % pcfmt(nump1prev,
                                                               numprev))
             ui.write(('    where prev = p2  : ') + fmt2 % pcfmt(nump2prev,
                                                               numprev))
             ui.write(('    other            : ') + fmt2 % pcfmt(numoprev,
                                                               numprev))
         if gdelta:
             ui.write(('deltas against p1    : ')
                      + fmt % pcfmt(nump1, numdeltas))
             ui.write(('deltas against p2    : ')
                      + fmt % pcfmt(nump2, numdeltas))
             ui.write(('deltas against other : ') + fmt % pcfmt(numother,
                                                              numdeltas))
 
 @command('debugrevspec',
     [('', 'optimize', None,
       _('print parsed tree after optimizing (DEPRECATED)')),
      ('', 'show-revs', True, _('print list of result revisions (default)')),
      ('s', 'show-set', None, _('print internal representation of result set')),
      ('p', 'show-stage', [],
       _('print parsed tree at the given stage'), _('NAME')),
      ('', 'no-optimized', False, _('evaluate tree without optimization')),
      ('', 'verify-optimized', False, _('verify optimized result')),
      ],
     ('REVSPEC'))
 def debugrevspec(ui, repo, expr, **opts):
     """parse and apply a revision specification
 
     Use -p/--show-stage option to print the parsed tree at the given stages.
     Use -p all to print tree at every stage.
 
     Use --no-show-revs option with -s or -p to print only the set
     representation or the parsed tree respectively.
 
     Use --verify-optimized to compare the optimized result with the unoptimized
     one. Returns 1 if the optimized result differs.
     """
     opts = pycompat.byteskwargs(opts)
     aliases = ui.configitems('revsetalias')
     stages = [
         ('parsed', lambda tree: tree),
         ('expanded', lambda tree: revsetlang.expandaliases(tree, aliases,
                                                            ui.warn)),
         ('concatenated', revsetlang.foldconcat),
         ('analyzed', revsetlang.analyze),
         ('optimized', revsetlang.optimize),
     ]
     if opts['no_optimized']:
         stages = stages[:-1]
     if opts['verify_optimized'] and opts['no_optimized']:
         raise error.Abort(_('cannot use --verify-optimized with '
                             '--no-optimized'))
     stagenames = set(n for n, f in stages)
 
     showalways = set()
     showchanged = set()
     if ui.verbose and not opts['show_stage']:
         # show parsed tree by --verbose (deprecated)
         showalways.add('parsed')
         showchanged.update(['expanded', 'concatenated'])
         if opts['optimize']:
             showalways.add('optimized')
     if opts['show_stage'] and opts['optimize']:
         raise error.Abort(_('cannot use --optimize with --show-stage'))
     if opts['show_stage'] == ['all']:
         showalways.update(stagenames)
     else:
         for n in opts['show_stage']:
             if n not in stagenames:
                 raise error.Abort(_('invalid stage name: %s') % n)
         showalways.update(opts['show_stage'])
 
     treebystage = {}
     printedtree = None
     tree = revsetlang.parse(expr, lookup=repo.__contains__)
     for n, f in stages:
         treebystage[n] = tree = f(tree)
         if n in showalways or (n in showchanged and tree != printedtree):
             if opts['show_stage'] or n != 'parsed':
                 ui.write(("* %s:\n") % n)
             ui.write(revsetlang.prettyformat(tree), "\n")
             printedtree = tree
 
     if opts['verify_optimized']:
         arevs = revset.makematcher(treebystage['analyzed'])(repo)
         brevs = revset.makematcher(treebystage['optimized'])(repo)
         if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
             ui.write(("* analyzed set:\n"), smartset.prettyformat(arevs), "\n")
             ui.write(("* optimized set:\n"), smartset.prettyformat(brevs), "\n")
         arevs = list(arevs)
         brevs = list(brevs)
         if arevs == brevs:
             return 0
         ui.write(('--- analyzed\n'), label='diff.file_a')
         ui.write(('+++ optimized\n'), label='diff.file_b')
         sm = difflib.SequenceMatcher(None, arevs, brevs)
         for tag, alo, ahi, blo, bhi in sm.get_opcodes():
             if tag in ('delete', 'replace'):
                 for c in arevs[alo:ahi]:
                     ui.write('-%s\n' % c, label='diff.deleted')
             if tag in ('insert', 'replace'):
                 for c in brevs[blo:bhi]:
                     ui.write('+%s\n' % c, label='diff.inserted')
             if tag == 'equal':
                 for c in arevs[alo:ahi]:
                     ui.write(' %s\n' % c)
         return 1
 
     func = revset.makematcher(tree)
     revs = func(repo)
     if opts['show_set'] or (opts['show_set'] is None and ui.verbose):
         ui.write(("* set:\n"), smartset.prettyformat(revs), "\n")
     if not opts['show_revs']:
         return
     for c in revs:
         ui.write("%d\n" % c)
 
 @command('debugserve', [
     ('', 'sshstdio', False, _('run an SSH server bound to process handles')),
     ('', 'logiofd', '', _('file descriptor to log server I/O to')),
     ('', 'logiofile', '', _('file to log server I/O to')),
 ], '')
 def debugserve(ui, repo, **opts):
     """run a server with advanced settings
 
     This command is similar to :hg:`serve`. It exists partially as a
     workaround to the fact that ``hg serve --stdio`` must have specific
     arguments for security reasons.
     """
     opts = pycompat.byteskwargs(opts)
 
     if not opts['sshstdio']:
         raise error.Abort(_('only --sshstdio is currently supported'))
 
     logfh = None
 
     if opts['logiofd'] and opts['logiofile']:
         raise error.Abort(_('cannot use both --logiofd and --logiofile'))
 
     if opts['logiofd']:
         # Line buffered because output is line based.
         logfh = os.fdopen(int(opts['logiofd']), r'ab', 1)
     elif opts['logiofile']:
         logfh = open(opts['logiofile'], 'ab', 1)
 
     s = wireprotoserver.sshserver(ui, repo, logfh=logfh)
     s.serve_forever()
 
 @command('debugsetparents', [], _('REV1 [REV2]'))
 def debugsetparents(ui, repo, rev1, rev2=None):
     """manually set the parents of the current working directory
 
     This is useful for writing repository conversion tools, but should
     be used with care. For example, neither the working directory nor the
     dirstate is updated, so file status may be incorrect after running this
     command.
 
     Returns 0 on success.
     """
 
     node1 = scmutil.revsingle(repo, rev1).node()
     node2 = scmutil.revsingle(repo, rev2, 'null').node()
 
     with repo.wlock():
         repo.setparents(node1, node2)
 
 @command('debugssl', [], '[SOURCE]', optionalrepo=True)
 def debugssl(ui, repo, source=None, **opts):
     '''test a secure connection to a server
 
     This builds the certificate chain for the server on Windows, installing the
     missing intermediates and trusted root via Windows Update if necessary.  It
     does nothing on other platforms.
 
     If SOURCE is omitted, the 'default' path will be used.  If a URL is given,
     that server is used. See :hg:`help urls` for more information.
 
     If the update succeeds, retry the original operation.  Otherwise, the cause
     of the SSL error is likely another issue.
     '''
     if not pycompat.iswindows:
         raise error.Abort(_('certificate chain building is only possible on '
                             'Windows'))
 
     if not source:
         if not repo:
             raise error.Abort(_("there is no Mercurial repository here, and no "
                                 "server specified"))
         source = "default"
 
     source, branches = hg.parseurl(ui.expandpath(source))
     url = util.url(source)
     addr = None
 
     defaultport = {'https': 443, 'ssh': 22}
     if url.scheme in defaultport:
         try:
             addr = (url.host, int(url.port or defaultport[url.scheme]))
         except ValueError:
             raise error.Abort(_("malformed port number in URL"))
     else:
         raise error.Abort(_("only https and ssh connections are supported"))
 
     from . import win32
 
     s = ssl.wrap_socket(socket.socket(), ssl_version=ssl.PROTOCOL_TLS,
                         cert_reqs=ssl.CERT_NONE, ca_certs=None)
 
     try:
         s.connect(addr)
         cert = s.getpeercert(True)
 
         ui.status(_('checking the certificate chain for %s\n') % url.host)
 
         complete = win32.checkcertificatechain(cert, build=False)
 
         if not complete:
             ui.status(_('certificate chain is incomplete, updating... '))
 
             if not win32.checkcertificatechain(cert):
                 ui.status(_('failed.\n'))
             else:
                 ui.status(_('done.\n'))
         else:
             ui.status(_('full certificate chain is available\n'))
     finally:
         s.close()
 
 @command('debugsub',
     [('r', 'rev', '',
      _('revision to check'), _('REV'))],
     _('[-r REV] [REV]'))
 def debugsub(ui, repo, rev=None):
     ctx = scmutil.revsingle(repo, rev, None)
     for k, v in sorted(ctx.substate.items()):
         ui.write(('path %s\n') % k)
         ui.write((' source   %s\n') % v[0])
         ui.write((' revision %s\n') % v[1])
 
 @command('debugsuccessorssets',
     [('', 'closest', False, _('return closest successors sets only'))],
     _('[REV]'))
 def debugsuccessorssets(ui, repo, *revs, **opts):
     """show set of successors for revision
 
     A successors set of changeset A is a consistent group of revisions that
     succeed A. It contains non-obsolete changesets only unless closests
     successors set is set.
 
     In most cases a changeset A has a single successors set containing a single
     successor (changeset A replaced by A').
 
     A changeset that is made obsolete with no successors are called "pruned".
     Such changesets have no successors sets at all.
 
     A changeset that has been "split" will have a successors set containing
     more than one successor.
 
     A changeset that has been rewritten in multiple different ways is called
     "divergent". Such changesets have multiple successor sets (each of which
     may also be split, i.e. have multiple successors).
 
     Results are displayed as follows::
 
         <rev1>
             <successors-1A>
         <rev2>
             <successors-2A>
             <successors-2B1> <successors-2B2> <successors-2B3>
 
     Here rev2 has two possible (i.e. divergent) successors sets. The first
     holds one element, whereas the second holds three (i.e. the changeset has
     been split).
     """
     # passed to successorssets caching computation from one call to another
     cache = {}
     ctx2str = bytes
     node2str = short
     for rev in scmutil.revrange(repo, revs):
         ctx = repo[rev]
         ui.write('%s\n'% ctx2str(ctx))
         for succsset in obsutil.successorssets(repo, ctx.node(),
                                                 closest=opts[r'closest'],
                                                 cache=cache):
             if succsset:
                 ui.write('    ')
                 ui.write(node2str(succsset[0]))
                 for node in succsset[1:]:
                     ui.write(' ')
                     ui.write(node2str(node))
             ui.write('\n')
 
 @command('debugtemplate',
     [('r', 'rev', [], _('apply template on changesets'), _('REV')),
      ('D', 'define', [], _('define template keyword'), _('KEY=VALUE'))],
     _('[-r REV]... [-D KEY=VALUE]... TEMPLATE'),
     optionalrepo=True)
 def debugtemplate(ui, repo, tmpl, **opts):
     """parse and apply a template
 
     If -r/--rev is given, the template is processed as a log template and
     applied to the given changesets. Otherwise, it is processed as a generic
     template.
 
     Use --verbose to print the parsed tree.
     """
     revs = None
     if opts[r'rev']:
         if repo is None:
             raise error.RepoError(_('there is no Mercurial repository here '
                                     '(.hg not found)'))
         revs = scmutil.revrange(repo, opts[r'rev'])
 
     props = {}
     for d in opts[r'define']:
         try:
             k, v = (e.strip() for e in d.split('=', 1))
             if not k or k == 'ui':
                 raise ValueError
             props[k] = v
         except ValueError:
             raise error.Abort(_('malformed keyword definition: %s') % d)
 
     if ui.verbose:
         aliases = ui.configitems('templatealias')
         tree = templater.parse(tmpl)
         ui.note(templater.prettyformat(tree), '\n')
         newtree = templater.expandaliases(tree, aliases)
         if newtree != tree:
             ui.note(("* expanded:\n"), templater.prettyformat(newtree), '\n')
 
     if revs is None:
         tres = formatter.templateresources(ui, repo)
         t = formatter.maketemplater(ui, tmpl, resources=tres)
         ui.write(t.renderdefault(props))
     else:
         displayer = logcmdutil.maketemplater(ui, repo, tmpl)
         for r in revs:
             displayer.show(repo[r], **pycompat.strkwargs(props))
         displayer.close()
 
 @command('debuguigetpass', [
     ('p', 'prompt', '', _('prompt text'), _('TEXT')),
 ], _('[-p TEXT]'), norepo=True)
 def debuguigetpass(ui, prompt=''):
     """show prompt to type password"""
     r = ui.getpass(prompt)
     ui.write(('respose: %s\n') % r)
 
 @command('debuguiprompt', [
     ('p', 'prompt', '', _('prompt text'), _('TEXT')),
 ], _('[-p TEXT]'), norepo=True)
 def debuguiprompt(ui, prompt=''):
     """show plain prompt"""
     r = ui.prompt(prompt)
     ui.write(('response: %s\n') % r)
 
 @command('debugupdatecaches', [])
 def debugupdatecaches(ui, repo, *pats, **opts):
     """warm all known caches in the repository"""
     with repo.wlock(), repo.lock():
         repo.updatecaches(full=True)
 
 @command('debugupgraderepo', [
     ('o', 'optimize', [], _('extra optimization to perform'), _('NAME')),
     ('', 'run', False, _('performs an upgrade')),
 ])
 def debugupgraderepo(ui, repo, run=False, optimize=None):
     """upgrade a repository to use different features
 
     If no arguments are specified, the repository is evaluated for upgrade
     and a list of problems and potential optimizations is printed.
 
     With ``--run``, a repository upgrade is performed. Behavior of the upgrade
     can be influenced via additional arguments. More details will be provided
     by the command output when run without ``--run``.
 
     During the upgrade, the repository will be locked and no writes will be
     allowed.
 
     At the end of the upgrade, the repository may not be readable while new
     repository data is swapped in. This window will be as long as it takes to
     rename some directories inside the ``.hg`` directory. On most machines, this
     should complete almost instantaneously and the chances of a consumer being
     unable to access the repository should be low.
     """
     return upgrade.upgraderepo(ui, repo, run=run, optimize=optimize)
 
 @command('debugwalk', cmdutil.walkopts, _('[OPTION]... [FILE]...'),
          inferrepo=True)
 def debugwalk(ui, repo, *pats, **opts):
     """show how files match on given patterns"""
     opts = pycompat.byteskwargs(opts)
     m = scmutil.match(repo[None], pats, opts)
     ui.write(('matcher: %r\n' % m))
     items = list(repo[None].walk(m))
     if not items:
         return
     f = lambda fn: fn
     if ui.configbool('ui', 'slash') and pycompat.ossep != '/':
         f = lambda fn: util.normpath(fn)
     fmt = 'f  %%-%ds  %%-%ds  %%s' % (
         max([len(abs) for abs in items]),
         max([len(m.rel(abs)) for abs in items]))
     for abs in items:
         line = fmt % (abs, f(m.rel(abs)), m.exact(abs) and 'exact' or '')
         ui.write("%s\n" % line.rstrip())
 
 @command('debugwhyunstable', [], _('REV'))
 def debugwhyunstable(ui, repo, rev):
     """explain instabilities of a changeset"""
     for entry in obsutil.whyunstable(repo, repo[rev]):
         dnodes = ''
         if entry.get('divergentnodes'):
             dnodes = ' '.join('%s (%s)' % (ctx.hex(), ctx.phasestr())
                               for ctx in entry['divergentnodes']) + ' '
         ui.write('%s: %s%s %s\n' % (entry['instability'], dnodes,
                                     entry['reason'], entry['node']))
 
 @command('debugwireargs',
     [('', 'three', '', 'three'),
     ('', 'four', '', 'four'),
     ('', 'five', '', 'five'),
     ] + cmdutil.remoteopts,
     _('REPO [OPTIONS]... [ONE [TWO]]'),
     norepo=True)
 def debugwireargs(ui, repopath, *vals, **opts):
     opts = pycompat.byteskwargs(opts)
     repo = hg.peer(ui, opts, repopath)
     for opt in cmdutil.remoteopts:
         del opts[opt[1]]
     args = {}
     for k, v in opts.iteritems():
         if v:
             args[k] = v
     args = pycompat.strkwargs(args)
     # run twice to check that we don't mess up the stream for the next command
     res1 = repo.debugwireargs(*vals, **args)
     res2 = repo.debugwireargs(*vals, **args)
     ui.write("%s\n" % res1)
     if res1 != res2:
         ui.warn("%s\n" % res2)
 
 def _parsewirelangblocks(fh):
     activeaction = None
     blocklines = []
 
     for line in fh:
         line = line.rstrip()
         if not line:
             continue
 
         if line.startswith(b'#'):
             continue
 
         if not line.startswith(' '):
             # New block. Flush previous one.
             if activeaction:
                 yield activeaction, blocklines
 
             activeaction = line
             blocklines = []
             continue
 
         # Else we start with an indent.
 
         if not activeaction:
             raise error.Abort(_('indented line outside of block'))
 
         blocklines.append(line)
 
     # Flush last block.
     if activeaction:
         yield activeaction, blocklines
 
 @command('debugwireproto',
     [
         ('', 'localssh', False, _('start an SSH server for this repo')),
         ('', 'peer', '', _('construct a specific version of the peer')),
         ('', 'noreadstderr', False, _('do not read from stderr of the remote')),
     ] + cmdutil.remoteopts,
     _('[PATH]'),
     optionalrepo=True)
 def debugwireproto(ui, repo, path=None, **opts):
     """send wire protocol commands to a server
 
     This command can be used to issue wire protocol commands to remote
     peers and to debug the raw data being exchanged.
 
     ``--localssh`` will start an SSH server against the current repository
     and connect to that. By default, the connection will perform a handshake
     and establish an appropriate peer instance.
 
     ``--peer`` can be used to bypass the handshake protocol and construct a
     peer instance using the specified class type. Valid values are ``raw``,
     ``ssh1``, and ``ssh2``. ``raw`` instances only allow sending raw data
     payloads and don't support higher-level command actions.
 
     ``--noreadstderr`` can be used to disable automatic reading from stderr
     of the peer (for SSH connections only). Disabling automatic reading of
     stderr is useful for making output more deterministic.
 
     Commands are issued via a mini language which is specified via stdin.
     The language consists of individual actions to perform. An action is
     defined by a block. A block is defined as a line with no leading
     space followed by 0 or more lines with leading space. Blocks are
     effectively a high-level command with additional metadata.
 
     Lines beginning with ``#`` are ignored.
 
     The following sections denote available actions.
 
     raw
     ---
 
     Send raw data to the server.
 
     The block payload contains the raw data to send as one atomic send
     operation. The data may not actually be delivered in a single system
     call: it depends on the abilities of the transport being used.
 
     Each line in the block is de-indented and concatenated. Then, that
     value is evaluated as a Python b'' literal. This allows the use of
     backslash escaping, etc.
 
     raw+
     ----
 
     Behaves like ``raw`` except flushes output afterwards.
 
     command <X>
     -----------
 
     Send a request to run a named command, whose name follows the ``command``
     string.
 
     Arguments to the command are defined as lines in this block. The format of
     each line is ``<key> <value>``. e.g.::
 
        command listkeys
            namespace bookmarks
 
     Values are interpreted as Python b'' literals. This allows encoding
     special byte sequences via backslash escaping.
 
     The following arguments have special meaning:
 
     ``PUSHFILE``
         When defined, the *push* mechanism of the peer will be used instead
         of the static request-response mechanism and the content of the
         file specified in the value of this argument will be sent as the
         command payload.
 
         This can be used to submit a local bundle file to the remote.
 
     batchbegin
     ----------
 
     Instruct the peer to begin a batched send.
 
     All ``command`` blocks are queued for execution until the next
     ``batchsubmit`` block.
 
     batchsubmit
     -----------
 
     Submit previously queued ``command`` blocks as a batch request.
 
     This action MUST be paired with a ``batchbegin`` action.
 
     httprequest <method> <path>
     ---------------------------
 
     (HTTP peer only)
 
     Send an HTTP request to the peer.
 
     The HTTP request line follows the ``httprequest`` action. e.g. ``GET /foo``.
 
     Arguments of the form ``<key>: <value>`` are interpreted as HTTP request
     headers to add to the request. e.g. ``Accept: foo``.
 
     The following arguments are special:
 
     ``BODYFILE``
         The content of the file defined as the value to this argument will be
         transferred verbatim as the HTTP request body.
 
     ``frame <type> <flags> <payload>``
         Send a unified protocol frame as part of the request body.
 
         All frames will be collected and sent as the body to the HTTP
         request.
 
     close
     -----
 
     Close the connection to the server.
 
     flush
     -----
 
     Flush data written to the server.
 
     readavailable
     -------------
 
     Close the write end of the connection and read all available data from
     the server.
 
     If the connection to the server encompasses multiple pipes, we poll both
     pipes and read available data.
 
     readline
     --------
 
     Read a line of output from the server. If there are multiple output
     pipes, reads only the main pipe.
 
     ereadline
     ---------
 
     Like ``readline``, but read from the stderr pipe, if available.
 
     read <X>
     --------
 
     ``read()`` N bytes from the server's main output pipe.
 
     eread <X>
     ---------
 
     ``read()`` N bytes from the server's stderr pipe, if available.
 
     Specifying Unified Frame-Based Protocol Frames
     ----------------------------------------------
 
     It is possible to emit a *Unified Frame-Based Protocol* by using special
     syntax.
 
     A frame is composed as a type, flags, and payload. These can be parsed
     from a string of the form ``<requestid> <type> <flags> <payload>``. That is,
     4 space-delimited strings.
 
     ``payload`` is the simplest: it is evaluated as a Python byte string
     literal.
 
     ``requestid`` is an integer defining the request identifier.
 
     ``type`` can be an integer value for the frame type or the string name
     of the type. The strings are defined in ``wireprotoframing.py``. e.g.
     ``command-name``.
 
     ``flags`` is a ``|`` delimited list of flag components. Each component
     (and there can be just one) can be an integer or a flag name for the
     specified frame type. Values are resolved to integers and then bitwise
     OR'd together.
     """
     opts = pycompat.byteskwargs(opts)
 
     if opts['localssh'] and not repo:
         raise error.Abort(_('--localssh requires a repository'))
 
     if opts['peer'] and opts['peer'] not in ('raw', 'ssh1', 'ssh2'):
         raise error.Abort(_('invalid value for --peer'),
                           hint=_('valid values are "raw", "ssh1", and "ssh2"'))
 
     if path and opts['localssh']:
         raise error.Abort(_('cannot specify --localssh with an explicit '
                             'path'))
 
     if ui.interactive():
         ui.write(_('(waiting for commands on stdin)\n'))
 
     blocks = list(_parsewirelangblocks(ui.fin))
 
     proc = None
     stdin = None
     stdout = None
     stderr = None
     opener = None
 
     if opts['localssh']:
         # We start the SSH server in its own process so there is process
         # separation. This prevents a whole class of potential bugs around
         # shared state from interfering with server operation.
         args = procutil.hgcmd() + [
             '-R', repo.root,
             'debugserve', '--sshstdio',
         ]
         proc = subprocess.Popen(args, stdin=subprocess.PIPE,
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                 bufsize=0)
 
         stdin = proc.stdin
         stdout = proc.stdout
         stderr = proc.stderr
 
         # We turn the pipes into observers so we can log I/O.
         if ui.verbose or opts['peer'] == 'raw':
             stdin = util.makeloggingfileobject(ui, proc.stdin, b'i',
                                                logdata=True)
             stdout = util.makeloggingfileobject(ui, proc.stdout, b'o',
                                                 logdata=True)
             stderr = util.makeloggingfileobject(ui, proc.stderr, b'e',
                                                 logdata=True)
 
         # --localssh also implies the peer connection settings.
 
         url = 'ssh://localserver'
         autoreadstderr = not opts['noreadstderr']
 
         if opts['peer'] == 'ssh1':
             ui.write(_('creating ssh peer for wire protocol version 1\n'))
             peer = sshpeer.sshv1peer(ui, url, proc, stdin, stdout, stderr,
                                      None, autoreadstderr=autoreadstderr)
         elif opts['peer'] == 'ssh2':
             ui.write(_('creating ssh peer for wire protocol version 2\n'))
             peer = sshpeer.sshv2peer(ui, url, proc, stdin, stdout, stderr,
                                      None, autoreadstderr=autoreadstderr)
         elif opts['peer'] == 'raw':
             ui.write(_('using raw connection to peer\n'))
             peer = None
         else:
             ui.write(_('creating ssh peer from handshake results\n'))
             peer = sshpeer.makepeer(ui, url, proc, stdin, stdout, stderr,
                                     autoreadstderr=autoreadstderr)
 
     elif path:
         # We bypass hg.peer() so we can proxy the sockets.
         # TODO consider not doing this because we skip
         # ``hg.wirepeersetupfuncs`` and potentially other useful functionality.
         u = util.url(path)
         if u.scheme != 'http':
             raise error.Abort(_('only http:// paths are currently supported'))
 
         url, authinfo = u.authinfo()
         openerargs = {}
 
         # Turn pipes/sockets into observers so we can log I/O.
         if ui.verbose:
             openerargs = {
                 r'loggingfh': ui,
                 r'loggingname': b's',
                 r'loggingopts': {
                     r'logdata': True,
                     r'logdataapis': False,
                 },
             }
 
         if ui.debugflag:
             openerargs[r'loggingopts'][r'logdataapis'] = True
 
         # Don't send default headers when in raw mode. This allows us to
         # bypass most of the behavior of our URL handling code so we can
         # have near complete control over what's sent on the wire.
         if opts['peer'] == 'raw':
             openerargs[r'sendaccept'] = False
 
         opener = urlmod.opener(ui, authinfo, **openerargs)
 
         if opts['peer'] == 'raw':
             ui.write(_('using raw connection to peer\n'))
             peer = None
         elif opts['peer']:
             raise error.Abort(_('--peer %s not supported with HTTP peers') %
                               opts['peer'])
         else:
             peer = httppeer.httppeer(ui, path, url, opener)
             peer._fetchcaps()
 
         # We /could/ populate stdin/stdout with sock.makefile()...
     else:
         raise error.Abort(_('unsupported connection configuration'))
 
     batchedcommands = None
 
     # Now perform actions based on the parsed wire language instructions.
     for action, lines in blocks:
         if action in ('raw', 'raw+'):
             if not stdin:
                 raise error.Abort(_('cannot call raw/raw+ on this peer'))
 
             # Concatenate the data together.
             data = ''.join(l.lstrip() for l in lines)
             data = stringutil.unescapestr(data)
             stdin.write(data)
 
             if action == 'raw+':
                 stdin.flush()
         elif action == 'flush':
             if not stdin:
                 raise error.Abort(_('cannot call flush on this peer'))
             stdin.flush()
         elif action.startswith('command'):
             if not peer:
                 raise error.Abort(_('cannot send commands unless peer instance '
                                     'is available'))
 
             command = action.split(' ', 1)[1]
 
             args = {}
             for line in lines:
                 # We need to allow empty values.
                 fields = line.lstrip().split(' ', 1)
                 if len(fields) == 1:
                     key = fields[0]
                     value = ''
                 else:
                     key, value = fields
 
                 args[key] = stringutil.unescapestr(value)
 
             if batchedcommands is not None:
                 batchedcommands.append((command, args))
                 continue
 
             ui.status(_('sending %s command\n') % command)
 
             if 'PUSHFILE' in args:
                 with open(args['PUSHFILE'], r'rb') as fh:
                     del args['PUSHFILE']
                     res, output = peer._callpush(command, fh,
                                                  **pycompat.strkwargs(args))
                     ui.status(_('result: %s\n') % stringutil.escapedata(res))
                     ui.status(_('remote output: %s\n') %
                               stringutil.escapedata(output))
             else:
                 res = peer._call(command, **pycompat.strkwargs(args))
                 ui.status(_('response: %s\n') % stringutil.escapedata(res))
 
         elif action == 'batchbegin':
             if batchedcommands is not None:
                 raise error.Abort(_('nested batchbegin not allowed'))
 
             batchedcommands = []
         elif action == 'batchsubmit':
             # There is a batching API we could go through. But it would be
             # difficult to normalize requests into function calls. It is easier
             # to bypass this layer and normalize to commands + args.
             ui.status(_('sending batch with %d sub-commands\n') %
                       len(batchedcommands))
             for i, chunk in enumerate(peer._submitbatch(batchedcommands)):
                 ui.status(_('response #%d: %s\n') %
                           (i, stringutil.escapedata(chunk)))
 
             batchedcommands = None
 
         elif action.startswith('httprequest '):
             if not opener:
                 raise error.Abort(_('cannot use httprequest without an HTTP '
                                     'peer'))
 
             request = action.split(' ', 2)
             if len(request) != 3:
                 raise error.Abort(_('invalid httprequest: expected format is '
                                     '"httprequest <method> <path>'))
 
             method, httppath = request[1:]
             headers = {}
             body = None
             frames = []
             for line in lines:
                 line = line.lstrip()
                 m = re.match(b'^([a-zA-Z0-9_-]+): (.*)$', line)
                 if m:
                     headers[m.group(1)] = m.group(2)
                     continue
 
                 if line.startswith(b'BODYFILE '):
                     with open(line.split(b' ', 1), 'rb') as fh:
                         body = fh.read()
                 elif line.startswith(b'frame '):
                     frame = wireprotoframing.makeframefromhumanstring(
                         line[len(b'frame '):])
 
                     frames.append(frame)
                 else:
                     raise error.Abort(_('unknown argument to httprequest: %s') %
                                       line)
 
             url = path + httppath
 
             if frames:
                 body = b''.join(bytes(f) for f in frames)
 
             req = urlmod.urlreq.request(pycompat.strurl(url), body, headers)
 
             # urllib.Request insists on using has_data() as a proxy for
             # determining the request method. Override that to use our
             # explicitly requested method.
             req.get_method = lambda: method
 
             try:
                 opener.open(req).read()
             except util.urlerr.urlerror as e:
                 e.read()
 
         elif action == 'close':
             peer.close()
         elif action == 'readavailable':
             if not stdout or not stderr:
                 raise error.Abort(_('readavailable not available on this peer'))
 
             stdin.close()
             stdout.read()
             stderr.read()
 
         elif action == 'readline':
             if not stdout:
                 raise error.Abort(_('readline not available on this peer'))
             stdout.readline()
         elif action == 'ereadline':
             if not stderr:
                 raise error.Abort(_('ereadline not available on this peer'))
             stderr.readline()
         elif action.startswith('read '):
             count = int(action.split(' ', 1)[1])
             if not stdout:
                 raise error.Abort(_('read not available on this peer'))
             stdout.read(count)
         elif action.startswith('eread '):
             count = int(action.split(' ', 1)[1])
             if not stderr:
                 raise error.Abort(_('eread not available on this peer'))
             stderr.read(count)
         else:
             raise error.Abort(_('unknown action: %s') % action)
 
     if batchedcommands is not None:
         raise error.Abort(_('unclosed "batchbegin" request'))
 
     if peer:
         peer.close()
 
     if proc:
         proc.kill()

tests/test-changelog-exec.t

@@ -1,57 +1,57 b''
 #require execbit
 
 b51a8138292a introduced a regression where we would mention in the
 changelog executable files added by the second parent of a merge. Test
 that that doesn't happen anymore
 
   $ hg init repo
   $ cd repo
   $ echo foo > foo
   $ hg ci -qAm 'add foo'
 
   $ echo bar > bar
   $ chmod +x bar
   $ hg ci -qAm 'add bar'
 
 manifest of p2:
 
   $ hg manifest
   bar
   foo
 
   $ hg up -qC 0
   $ echo >> foo
   $ hg ci -m 'change foo'
   created new head
 
 manifest of p1:
 
   $ hg manifest
   foo
 
   $ hg merge
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ chmod +x foo
   $ hg ci -m 'merge'
 
 this should not mention bar but should mention foo:
 
   $ hg tip -v
   changeset:   3:c53d17ff3380
   tag:         tip
   parent:      2:ed1b79f46b9a
   parent:      1:d394a8db219b
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo
   description:
   merge
   
   
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       5       1 b004912a8510 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       1 b004912a8510 000000000000 000000000000
 
   $ cd ..

tests/test-clone-r.t

@@ -1,254 +1,254 b''
   $ hg init test
   $ cd test
 
   $ echo 0 >> afile
   $ hg add afile
   $ hg commit -m "0.0"
 
   $ echo 1 >> afile
   $ hg commit -m "0.1"
 
   $ echo 2 >> afile
   $ hg commit -m "0.2"
 
   $ echo 3 >> afile
   $ hg commit -m "0.3"
 
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo 1 >> afile
   $ hg commit -m "1.1"
   created new head
 
   $ echo 2 >> afile
   $ hg commit -m "1.2"
 
   $ echo a line > fred
   $ echo 3 >> afile
   $ hg add fred
   $ hg commit -m "1.3"
   $ hg mv afile adifferentfile
   $ hg commit -m "1.3m"
 
   $ hg update -C 3
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ hg mv afile anotherfile
   $ hg commit -m "0.3m"
 
   $ hg debugindex -f 1 afile
-     rev flag   offset   length     size   link     p1     p2       nodeid
-       0 0000        0        3        2      0     -1     -1 362fef284ce2
-       1 0000        3        5        4      1      0     -1 125144f7e028
-       2 0000        8        7        6      2      1     -1 4c982badb186
-       3 0000       15        9        8      3      2     -1 19b1fc555737
+     rev flag     size   link     p1     p2       nodeid
+       0 0000        2      0     -1     -1 362fef284ce2
+       1 0000        4      1      0     -1 125144f7e028
+       2 0000        6      2      1     -1 4c982badb186
+       3 0000        8      3      2     -1 19b1fc555737
 
   $ hg debugindex adifferentfile
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      75       7 2565f3199a74 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       7 2565f3199a74 000000000000 000000000000
 
   $ hg debugindex anotherfile
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      75       8 2565f3199a74 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       8 2565f3199a74 000000000000 000000000000
 
   $ hg debugindex fred
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       8       6 12ab3bcc5ea4 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       6 12ab3bcc5ea4 000000000000 000000000000
 
   $ hg debugindex --manifest
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      48       0 43eadb1d2d06 000000000000 000000000000
-       1        48      48       1 8b89697eba2c 43eadb1d2d06 000000000000
-       2        96      48       2 626a32663c2f 8b89697eba2c 000000000000
-       3       144      48       3 f54c32f13478 626a32663c2f 000000000000
-       4       192      ..       6 de68e904d169 626a32663c2f 000000000000 (re)
-       5       2..      ..       7 09bb521d218d de68e904d169 000000000000 (re)
-       6       3..      54       8 1fde233dfb0f f54c32f13478 000000000000 (re)
+     rev linkrev nodeid       p1           p2
+       0       0 43eadb1d2d06 000000000000 000000000000
+       1       1 8b89697eba2c 43eadb1d2d06 000000000000
+       2       2 626a32663c2f 8b89697eba2c 000000000000
+       3       3 f54c32f13478 626a32663c2f 000000000000
+       4       6 de68e904d169 626a32663c2f 000000000000
+       5       7 09bb521d218d de68e904d169 000000000000
+       6       8 1fde233dfb0f f54c32f13478 000000000000
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 9 changesets, 7 total revisions
 
   $ cd ..
 
   $ for i in 0 1 2 3 4 5 6 7 8; do
   >   echo
   >   echo ---- hg clone -r "$i" test test-"$i"
   >   hg clone -r "$i" test test-"$i"
   >   cd test-"$i"
   >   hg verify
   >   cd ..
   > done
   
   ---- hg clone -r 0 test test-0
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets f9ee2f85a263
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   
   ---- hg clone -r 1 test test-1
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets f9ee2f85a263:34c2bf6b0626
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 2 changesets, 2 total revisions
   
   ---- hg clone -r 2 test test-2
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets f9ee2f85a263:e38ba6f5b7e0
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 3 changesets, 3 total revisions
   
   ---- hg clone -r 3 test test-3
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 1 files
   new changesets f9ee2f85a263:eebf5a27f8ca
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 4 changesets, 4 total revisions
   
   ---- hg clone -r 4 test test-4
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets f9ee2f85a263:095197eb4973
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 2 changesets, 2 total revisions
   
   ---- hg clone -r 5 test test-5
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets f9ee2f85a263:1bb50a9436a7
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 3 changesets, 3 total revisions
   
   ---- hg clone -r 6 test test-6
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 5 changes to 2 files
   new changesets f9ee2f85a263:7373c1169842
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 4 changesets, 5 total revisions
   
   ---- hg clone -r 7 test test-7
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 6 changes to 3 files
   new changesets f9ee2f85a263:a6a34bfa0076
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   3 files, 5 changesets, 6 total revisions
   
   ---- hg clone -r 8 test test-8
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 2 files
   new changesets f9ee2f85a263:aa35859c02ea
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 5 changesets, 5 total revisions
 
   $ cd test-8
   $ hg pull ../test-7
   pulling from ../test-7
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 2 changes to 3 files (+1 heads)
   new changesets 095197eb4973:a6a34bfa0076
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 9 changesets, 7 total revisions
   $ cd ..
 
   $ hg clone test test-9
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd test-9
   $ hg branch foobar
   marked working directory as branch foobar
   (branches are permanent and global, did you want a bookmark?)
   $ echo file2 >> file2
   $ hg add file2
   $ hg commit -m "changeset9"
   $ echo file3 >> file3
   $ hg add file3
   $ hg commit -m "changeset10"
   $ cd ..
   $ hg clone -r 9 -u foobar test-9 test-10
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 6 changes to 3 files
   new changesets f9ee2f85a263:7100abb79635
   updating to branch foobar
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 

tests/test-commit-amend.t

@@ -1,1288 +1,1288 b''
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usegeneraldelta=yes
   > EOF
 
   $ hg init
 
 Setup:
 
   $ echo a >> a
   $ hg ci -Am 'base'
   adding a
 
 Refuse to amend public csets:
 
   $ hg phase -r . -p
   $ hg ci --amend
   abort: cannot amend public changesets
   (see 'hg help phases' for details)
   [255]
   $ hg phase -r . -f -d
 
   $ echo a >> a
   $ hg ci -Am 'base1'
 
 Nothing to amend:
 
   $ hg ci --amend -m 'base1'
   nothing changed
   [1]
 
   $ cat >> $HGRCPATH <<EOF
   > [hooks]
   > pretxncommit.foo = sh -c "echo \\"pretxncommit \$HG_NODE\\"; hg id -r \$HG_NODE"
   > EOF
 
 Amending changeset with changes in working dir:
 (and check that --message does not trigger an editor)
 
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -m 'amend base1'
   pretxncommit 43f1ba15f28a50abf0aae529cf8a16bfced7b149
   43f1ba15f28a tip
   saved backup bundle to $TESTTMP/.hg/strip-backup/489edb5b847d-5ab4f721-amend.hg
   $ echo 'pretxncommit.foo = ' >> $HGRCPATH
   $ hg diff -c .
   diff -r ad120869acf0 -r 43f1ba15f28a a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,3 @@
    a
   +a
   +a
   $ hg log
   changeset:   1:43f1ba15f28a
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     amend base1
   
   changeset:   0:ad120869acf0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     base
   
 
 Check proper abort for empty message
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > echo "" > "$1"
   > __EOF__
 
 Update the existing file to ensure that the dirstate is not in pending state
 (where the status of some files in the working copy is not known yet). This in
 turn ensures that when the transaction is aborted due to an empty message during
 the amend, there should be no rollback.
   $ echo a >> a
 
   $ echo b > b
   $ hg add b
   $ hg summary
   parent: 1:43f1ba15f28a tip
    amend base1
   branch: default
   commit: 1 modified, 1 added, 1 unknown
   update: (current)
   phases: 2 draft
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
   abort: empty commit message
   [255]
   $ hg summary
   parent: 1:43f1ba15f28a tip
    amend base1
   branch: default
   commit: 1 modified, 1 added, 1 unknown
   update: (current)
   phases: 2 draft
 
 Add new file along with modified existing file:
   $ hg ci --amend -m 'amend base1 new file'
   saved backup bundle to $TESTTMP/.hg/strip-backup/43f1ba15f28a-007467c2-amend.hg
 
 Remove file that was added in amended commit:
 (and test logfile option)
 (and test that logfile option do not trigger an editor)
 
   $ hg rm b
   $ echo 'amend base1 remove new file' > ../logfile
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg ci --amend --logfile ../logfile
   saved backup bundle to $TESTTMP/.hg/strip-backup/c16295aaf401-1ada9901-amend.hg
 
   $ hg cat b
   b: no such file in rev 47343646fa3d
   [1]
 
 No changes, just a different message:
 
   $ hg ci -v --amend -m 'no changes, new message'
   amending changeset 47343646fa3d
   copying changeset 47343646fa3d to ad120869acf0
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        254 (changelog)
        163 (manifests)
        131  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/47343646fa3d-c2758885-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        250 (changelog)
        163 (manifests)
        131  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:401431e913a1
   $ hg diff -c .
   diff -r ad120869acf0 -r 401431e913a1 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,4 @@
    a
   +a
   +a
   +a
   $ hg log
   changeset:   1:401431e913a1
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     no changes, new message
   
   changeset:   0:ad120869acf0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     base
   
 
 Disable default date on commit so when -d isn't given, the old date is preserved:
 
   $ echo '[defaults]' >> $HGRCPATH
   $ echo 'commit=' >> $HGRCPATH
 
 Test -u/-d:
 
   $ cat > .hg/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh .hg/checkeditform.sh" hg ci --amend -u foo -d '1 0'
   HGEDITFORM=commit.amend.normal
   saved backup bundle to $TESTTMP/.hg/strip-backup/401431e913a1-5e8e532c-amend.hg
   $ echo a >> a
   $ hg ci --amend -u foo -d '1 0'
   saved backup bundle to $TESTTMP/.hg/strip-backup/d96b1d28ae33-677e0afb-amend.hg
   $ hg log -r .
   changeset:   1:a9a13940fc03
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     no changes, new message
   
 
 Open editor with old commit message if a message isn't given otherwise:
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > cat $1
   > echo "another precious commit message" > "$1"
   > __EOF__
 
 at first, test saving last-message.txt
 
   $ cat > .hg/hgrc << '__EOF__'
   > [hooks]
   > pretxncommit.test-saving-last-message = false
   > __EOF__
 
   $ rm -f .hg/last-message.txt
   $ hg commit --amend -v -m "message given from command line"
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   committing files:
   a
   committing manifest
   committing changelog
   running hook pretxncommit.test-saving-last-message: false
   transaction abort!
   rollback completed
   abort: pretxncommit.test-saving-last-message hook exited with status 1
   [255]
   $ cat .hg/last-message.txt
   message given from command line (no-eol)
 
   $ rm -f .hg/last-message.txt
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   no changes, new message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   running hook pretxncommit.test-saving-last-message: false
   transaction abort!
   rollback completed
   abort: pretxncommit.test-saving-last-message hook exited with status 1
   [255]
 
   $ cat .hg/last-message.txt
   another precious commit message
 
   $ cat > .hg/hgrc << '__EOF__'
   > [hooks]
   > pretxncommit.test-saving-last-message =
   > __EOF__
 
 then, test editing custom commit message
 
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset a9a13940fc03
   copying changeset a9a13940fc03 to ad120869acf0
   no changes, new message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        249 (changelog)
        163 (manifests)
        133  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/a9a13940fc03-7c2e8674-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        133  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:64a124ba1b44
 
 Same, but with changes in working dir (different code path):
 
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend -v
   amending changeset 64a124ba1b44
   another precious commit message
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: foo
   HG: branch 'default'
   HG: changed a
   committing files:
   a
   committing manifest
   committing changelog
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        133  a
   saved backup bundle to $TESTTMP/.hg/strip-backup/64a124ba1b44-10374b8f-amend.hg
   1 changesets found
   uncompressed size of bundle content:
        257 (changelog)
        163 (manifests)
        135  a
   adding branch
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   committed changeset 1:7892795b8e38
 
   $ rm editor.sh
   $ hg log -r .
   changeset:   1:7892795b8e38
   tag:         tip
   user:        foo
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     another precious commit message
   
 
 Moving bookmarks, preserve active bookmark:
 
   $ hg book book1
   $ hg book book2
   $ hg ci --amend -m 'move bookmarks'
   saved backup bundle to $TESTTMP/.hg/strip-backup/7892795b8e38-3fb46217-amend.hg
   $ hg book
      book1                     1:8311f17e2616
    * book2                     1:8311f17e2616
   $ echo a >> a
   $ hg ci --amend -m 'move bookmarks'
   saved backup bundle to $TESTTMP/.hg/strip-backup/8311f17e2616-f0504fe3-amend.hg
   $ hg book
      book1                     1:a3b65065808c
    * book2                     1:a3b65065808c
 
 abort does not loose bookmarks
 
   $ cat > editor.sh << '__EOF__'
   > #!/bin/sh
   > echo "" > "$1"
   > __EOF__
   $ echo a >> a
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg commit --amend
   abort: empty commit message
   [255]
   $ hg book
      book1                     1:a3b65065808c
    * book2                     1:a3b65065808c
   $ hg revert -Caq
   $ rm editor.sh
 
   $ echo '[defaults]' >> $HGRCPATH
   $ echo "commit=-d '0 0'" >> $HGRCPATH
 
 Moving branches:
 
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -m 'branch foo'
   $ hg branch default -f
   marked working directory as branch default
   $ hg ci --amend -m 'back to default'
   saved backup bundle to $TESTTMP/.hg/strip-backup/f8339a38efe1-c18453c9-amend.hg
   $ hg branches
   default                        2:9c07515f2650
 
 Close branch:
 
   $ hg up -q 0
   $ echo b >> b
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -Am 'fork'
   adding b
   $ echo b >> b
   $ hg ci -mb
   $ hg ci --amend --close-branch -m 'closing branch foo'
   saved backup bundle to $TESTTMP/.hg/strip-backup/c962248fa264-54245dc7-amend.hg
 
 Same thing, different code path:
 
   $ echo b >> b
   $ hg ci -m 'reopen branch'
   reopening closed branch head 4
   $ echo b >> b
   $ hg ci --amend --close-branch
   saved backup bundle to $TESTTMP/.hg/strip-backup/027371728205-b900d9fa-amend.hg
   $ hg branches
   default                        2:9c07515f2650
 
 Refuse to amend during a merge:
 
   $ hg up -q default
   $ hg merge foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci --amend
   abort: cannot amend while merging
   [255]
   $ hg ci -m 'merge'
 
 Refuse to amend if there is a merge conflict (issue5805):
 
   $ hg up -q foo
   $ echo c > a
   $ hg up default -t :fail
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg resolve -l
   U a
 
   $ hg ci --amend
   abort: unresolved merge conflicts (see 'hg help resolve')
   [255]
 
   $ hg up -qC .
 
 Follow copies/renames:
 
   $ hg mv b c
   $ hg ci -m 'b -> c'
   $ hg mv c d
   $ hg ci --amend -m 'b -> d'
   saved backup bundle to $TESTTMP/.hg/strip-backup/42f3f27a067d-f23cc9f7-amend.hg
   $ hg st --rev '.^' --copies d
   A d
     b
   $ hg cp d e
   $ hg ci -m 'e = d'
   $ hg cp e f
   $ hg ci --amend -m 'f = d'
   saved backup bundle to $TESTTMP/.hg/strip-backup/9198f73182d5-251d584a-amend.hg
   $ hg st --rev '.^' --copies f
   A f
     d
 
   $ mv f f.orig
   $ hg rm -A f
   $ hg ci -m removef
   $ hg cp a f
   $ mv f.orig f
   $ hg ci --amend -m replacef
   saved backup bundle to $TESTTMP/.hg/strip-backup/f0993ab6b482-eda301bf-amend.hg
   $ hg st --change . --copies
   $ hg log -r . --template "{file_copies}\n"
   
 
 Move added file (issue3410):
 
   $ echo g >> g
   $ hg ci -Am g
   adding g
   $ hg mv g h
   $ hg ci --amend
   saved backup bundle to $TESTTMP/.hg/strip-backup/58585e3f095c-0f5ebcda-amend.hg
   $ hg st --change . --copies h
   A h
   $ hg log -r . --template "{file_copies}\n"
   
 
 Can't rollback an amend:
 
   $ hg rollback
   no rollback information available
   [1]
 
 Preserve extra dict (issue3430):
 
   $ hg branch a
   marked working directory as branch a
   (branches are permanent and global, did you want a bookmark?)
   $ echo a >> a
   $ hg ci -ma
   $ hg ci --amend -m "a'"
   saved backup bundle to $TESTTMP/.hg/strip-backup/39a162f1d65e-9dfe13d8-amend.hg
   $ hg log -r . --template "{branch}\n"
   a
   $ hg ci --amend -m "a''"
   saved backup bundle to $TESTTMP/.hg/strip-backup/d5ca7b1ac72b-0b4c1a34-amend.hg
   $ hg log -r . --template "{branch}\n"
   a
 
 Also preserve other entries in the dict that are in the old commit,
 first graft something so there's an additional entry:
 
   $ hg up 0 -q
   $ echo z > z
   $ hg ci -Am 'fork'
   adding z
   created new head
   $ hg up 11
   5 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg graft 12
   grafting 12:2647734878ef "fork" (tip)
   $ hg ci --amend -m 'graft amend'
   saved backup bundle to $TESTTMP/.hg/strip-backup/fe8c6f7957ca-25638666-amend.hg
   $ hg log -r . --debug | grep extra
   extra:       amend_source=fe8c6f7957ca1665ed77496ed7a07657d469ac60
   extra:       branch=a
   extra:       source=2647734878ef0236dda712fae9c1651cf694ea8a
 
 Preserve phase
 
   $ hg phase '.^::.'
   11: draft
   13: draft
   $ hg phase --secret --force .
   $ hg phase '.^::.'
   11: draft
   13: secret
   $ hg commit --amend -m 'amend for phase' -q
   $ hg phase '.^::.'
   11: draft
   13: secret
 
 Test amend with obsolete
 ---------------------------
 
 Enable obsolete
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > EOF
 
 Amend with no files changes
 
   $ hg id -n
   13
   $ hg ci --amend -m 'babar'
   $ hg id -n
   14
   $ hg log -Gl 3 --style=compact
   @  14[tip]:11   682950e85999   1970-01-01 00:00 +0000   test
   |    babar
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   ~
   $ hg log -Gl 4 --hidden --style=compact
   @  14[tip]:11   682950e85999   1970-01-01 00:00 +0000   test
   |    babar
   |
   | x  13:11   5167600b0f7a   1970-01-01 00:00 +0000   test
   |/     amend for phase
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   ~
 
 Amend with files changes
 
 (note: the extra commit over 15 is a temporary junk I would be happy to get
 ride of)
 
   $ echo 'babar' >> a
   $ hg commit --amend
   $ hg log -Gl 6 --hidden --style=compact
   @  15[tip]:11   a5b42b49b0d5   1970-01-01 00:00 +0000   test
   |    babar
   |
   | x  14:11   682950e85999   1970-01-01 00:00 +0000   test
   |/     babar
   |
   | x  13:11   5167600b0f7a   1970-01-01 00:00 +0000   test
   |/     amend for phase
   |
   | o  12:0   2647734878ef   1970-01-01 00:00 +0000   test
   | |    fork
   | ~
   o  11   0ddb275cfad1   1970-01-01 00:00 +0000   test
   |    a''
   |
   o  10   5fa75032e226   1970-01-01 00:00 +0000   test
   |    g
   ~
 
 
 Test that amend does not make it easy to create obsolescence cycle
 ---------------------------------------------------------------------
 
   $ hg id -r 14 --hidden
   682950e85999 (a)
   $ hg revert -ar 14 --hidden
   reverting a
   $ hg commit --amend
   $ hg id
   37973c7e0b61 (a) tip
 
 Test that rewriting leaving instability behind is allowed
 ---------------------------------------------------------------------
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'b' >> a
   $ hg log --style compact -r 'children(.)'
   16[tip]:11   37973c7e0b61   1970-01-01 00:00 +0000   test
     babar
   
   $ hg commit --amend
   1 new orphan changesets
   $ hg log -r 'orphan()'
   changeset:   16:37973c7e0b61
   branch:      a
   parent:      11:0ddb275cfad1
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   instability: orphan
   summary:     babar
   
 
 Amend a merge changeset (with renames and conflicts from the second parent):
 
   $ hg up -q default
   $ hg branch -q bar
   $ hg cp a aa
   $ hg mv z zz
   $ echo cc > cc
   $ hg add cc
   $ hg ci -m aazzcc
   $ hg up -q default
   $ echo a >> a
   $ echo dd > cc
   $ hg add cc
   $ hg ci -m aa
   $ hg merge -q bar
   warning: conflicts while merging cc! (edit, then use 'hg resolve --mark')
   [1]
   $ hg resolve -m cc
   (no more unresolved files)
   $ hg ci -m 'merge bar'
   $ hg log --config diff.git=1 -pr .
   changeset:   20:163cfd7219f7
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   diff --git a/z b/zz
   rename from z
   rename to zz
   
   $ hg debugrename aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
   $ hg debugrename zz
   zz renamed from z:69a1b67522704ec122181c0890bd16e9d3e7516a
   $ hg debugrename cc
   cc not renamed
   $ HGEDITOR="sh .hg/checkeditform.sh" hg ci --amend -m 'merge bar (amend message)' --edit
   HGEDITFORM=commit.amend.merge
   $ hg log --config diff.git=1 -pr .
   changeset:   21:bca52d4ed186
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (amend message)
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   diff --git a/z b/zz
   rename from z
   rename to zz
   
   $ hg debugrename aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
   $ hg debugrename zz
   zz renamed from z:69a1b67522704ec122181c0890bd16e9d3e7516a
   $ hg debugrename cc
   cc not renamed
   $ hg mv zz z
   $ hg ci --amend -m 'merge bar (undo rename)'
   $ hg log --config diff.git=1 -pr .
   changeset:   22:12594a98ca3f
   tag:         tip
   parent:      19:30d96aeaf27b
   parent:      18:1aa437659d19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (undo rename)
   
   diff --git a/a b/aa
   copy from a
   copy to aa
   diff --git a/cc b/cc
   --- a/cc
   +++ b/cc
   @@ -1,1 +1,5 @@
   +<<<<<<< working copy: 30d96aeaf27b - test: aa
    dd
   +=======
   +cc
   +>>>>>>> merge rev:    1aa437659d19 bar - test: aazzcc
   
   $ hg debugrename z
   z not renamed
 
 Amend a merge changeset (with renames during the merge):
 
   $ hg up -q bar
   $ echo x > x
   $ hg add x
   $ hg ci -m x
   $ hg up -q default
   $ hg merge -q bar
   $ hg mv aa aaa
   $ echo aa >> aaa
   $ hg ci -m 'merge bar again'
   $ hg log --config diff.git=1 -pr .
   changeset:   24:dffde028b388
   tag:         tip
   parent:      22:12594a98ca3f
   parent:      23:4c94d5bc65f5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar again
   
   diff --git a/aa b/aa
   deleted file mode 100644
   --- a/aa
   +++ /dev/null
   @@ -1,2 +0,0 @@
   -a
   -a
   diff --git a/aaa b/aaa
   new file mode 100644
   --- /dev/null
   +++ b/aaa
   @@ -0,0 +1,3 @@
   +a
   +a
   +aa
   diff --git a/x b/x
   new file mode 100644
   --- /dev/null
   +++ b/x
   @@ -0,0 +1,1 @@
   +x
   
   $ hg debugrename aaa
   aaa renamed from aa:37d9b5d994eab34eda9c16b195ace52c7b129980
   $ hg mv aaa aa
   $ hg ci --amend -m 'merge bar again (undo rename)'
   $ hg log --config diff.git=1 -pr .
   changeset:   25:18e3ba160489
   tag:         tip
   parent:      22:12594a98ca3f
   parent:      23:4c94d5bc65f5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar again (undo rename)
   
   diff --git a/aa b/aa
   --- a/aa
   +++ b/aa
   @@ -1,2 +1,3 @@
    a
    a
   +aa
   diff --git a/x b/x
   new file mode 100644
   --- /dev/null
   +++ b/x
   @@ -0,0 +1,1 @@
   +x
   
   $ hg debugrename aa
   aa not renamed
   $ hg debugrename -r '.^' aa
   aa renamed from a:a80d06849b333b8a3d5c445f8ba3142010dcdc9e
 
 Amend a merge changeset (with manifest-level conflicts):
 
   $ hg up -q bar
   $ hg rm aa
   $ hg ci -m 'rm aa'
   $ hg up -q default
   $ echo aa >> aa
   $ hg ci -m aa
   $ hg merge -q bar --config ui.interactive=True << EOF
   > c
   > EOF
   local [working copy] changed aa which other [merge rev] deleted
   use (c)hanged version, (d)elete, or leave (u)nresolved? c
   $ hg ci -m 'merge bar (with conflicts)'
   $ hg log --config diff.git=1 -pr .
   changeset:   28:b4c3035e2544
   tag:         tip
   parent:      27:4b216ca5ba97
   parent:      26:67db8847a540
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (with conflicts)
   
   
   $ hg rm aa
   $ hg ci --amend -m 'merge bar (with conflicts, amended)'
   $ hg log --config diff.git=1 -pr .
   changeset:   29:1205ed810051
   tag:         tip
   parent:      27:4b216ca5ba97
   parent:      26:67db8847a540
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge bar (with conflicts, amended)
   
   diff --git a/aa b/aa
   deleted file mode 100644
   --- a/aa
   +++ /dev/null
   @@ -1,4 +0,0 @@
   -a
   -a
   -aa
   -aa
   
 Issue 3445: amending with --close-branch a commit that created a new head should fail
 This shouldn't be possible:
 
   $ hg up -q default
   $ hg branch closewithamend
   marked working directory as branch closewithamend
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m..
   $ hg ci --amend --close-branch -m 'closing'
   abort: can only close branch heads
   [255]
 
 This silliness fails:
 
   $ hg branch silliness
   marked working directory as branch silliness
   $ echo b >> b
   $ hg ci --close-branch -m'open and close'
   abort: can only close branch heads
   [255]
 
 Test that amend with --secret creates new secret changeset forcibly
 ---------------------------------------------------------------------
 
   $ hg phase '.^::.'
   29: draft
   30: draft
   $ hg commit --amend --secret -m 'amend as secret' -q
   $ hg phase '.^::.'
   29: draft
   31: secret
 
 Test that amend with --edit invokes editor forcibly
 ---------------------------------------------------
 
   $ hg parents --template "{desc}\n"
   amend as secret
   $ HGEDITOR=cat hg commit --amend -m "editor should be suppressed"
   $ hg parents --template "{desc}\n"
   editor should be suppressed
 
   $ hg status --rev '.^1::.'
   A foo
   $ HGEDITOR=cat hg commit --amend -m "editor should be invoked" --edit
   editor should be invoked
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'silliness'
   HG: added foo
   $ hg parents --template "{desc}\n"
   editor should be invoked
 
 Test that "diff()" in committemplate works correctly for amending
 -----------------------------------------------------------------
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit.amend = {desc}\n
   >     HG: M: {file_mods}
   >     HG: A: {file_adds}
   >     HG: R: {file_dels}
   >     {splitlines(diff()) % 'HG: {line}\n'}
   > EOF
 
   $ hg parents --template "M: {file_mods}\nA: {file_adds}\nR: {file_dels}\n"
   M: 
   A: foo
   R: 
   $ hg status -amr
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of foo"
   expecting diff of foo
   
   HG: M: 
   HG: A: foo
   HG: R: 
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
 
   $ echo y > y
   $ hg add y
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of foo and y"
   expecting diff of foo and y
   
   HG: M: 
   HG: A: foo y
   HG: R: 
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ hg rm a
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of a, foo and y"
   expecting diff of a, foo and y
   
   HG: M: 
   HG: A: foo y
   HG: R: a
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ hg rm x
   $ HGEDITOR=cat hg commit --amend -e -m "expecting diff of a, foo, x and y"
   expecting diff of a, foo, x and y
   
   HG: M: 
   HG: A: foo y
   HG: R: a x
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 x
   HG: --- a/x	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +0,0 @@
   HG: -x
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
   $ echo cccc >> cc
   $ hg status -amr
   M cc
   $ HGEDITOR=cat hg commit --amend -e -m "cc should be excluded" -X cc
   cc should be excluded
   
   HG: M: 
   HG: A: foo y
   HG: R: a x
   HG: diff -r 1205ed810051 a
   HG: --- a/a	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,2 +0,0 @@
   HG: -a
   HG: -a
   HG: diff -r 1205ed810051 foo
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +foo
   HG: diff -r 1205ed810051 x
   HG: --- a/x	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +0,0 @@
   HG: -x
   HG: diff -r 1205ed810051 y
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/y	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +y
 
 Check for issue4405
 -------------------
 
 Setup the repo with a file that gets moved in a second commit.
   $ hg init repo
   $ cd repo
   $ touch a0
   $ hg add a0
   $ hg commit -m a0
   $ hg mv a0 a1
   $ hg commit -m a1
   $ hg up -q 0
   $ hg log -G --template '{rev} {desc}'
   o  1 a1
   |
   @  0 a0
   
 
 Now we branch the repro, but re-use the file contents, so we have a divergence
 in the file revlog topology and the changelog topology.
   $ hg revert --rev 1 --all
   removing a0
   adding a1
   $ hg ci -qm 'a1-amend'
   $ hg log -G --template '{rev} {desc}'
   @  2 a1-amend
   |
   | o  1 a1
   |/
   o  0 a0
   
 
 The way mercurial does amends is by folding the working copy and old commit
 together into another commit (rev 3). During this process, _findlimit is called
 to  check how far back to look for the transitive closure of file copy
 information, but due to the divergence of the filelog and changelog graph
 topologies, before _findlimit was fixed, it returned a rev which was not far
 enough back in this case.
   $ hg mv a1 a2
   $ hg status --copies --rev 0
   A a2
     a0
   R a0
   $ hg ci --amend -q
   $ hg log -G --template '{rev} {desc}'
   @  3 a1-amend
   |
   | o  1 a1
   |/
   o  0 a0
   
 
 Before the fix, the copy information was lost.
   $ hg status --copies --rev 0
   A a2
     a0
   R a0
   $ cd ..
 
 Check that amend properly preserve rename from directory rename (issue-4516)
 
 If a parent of the merge renames a full directory, any files added to the old
 directory in the other parent will be renamed to the new directory. For some
 reason, the rename metadata was when amending such merge. This test ensure we
 do not regress. We have a dedicated repo because it needs a setup with renamed
 directory)
 
   $ hg init issue4516
   $ cd issue4516
   $ mkdir olddirname
   $ echo line1 > olddirname/commonfile.py
   $ hg add olddirname/commonfile.py
   $ hg ci -m first
 
   $ hg branch newdirname
   marked working directory as branch newdirname
   (branches are permanent and global, did you want a bookmark?)
   $ hg mv olddirname newdirname
   moving olddirname/commonfile.py to newdirname/commonfile.py
   $ hg ci -m rename
 
   $ hg update default
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo line1 > olddirname/newfile.py
   $ hg add olddirname/newfile.py
   $ hg ci -m log
 
   $ hg up newdirname
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ # create newdirname/newfile.py
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m add
   $ 
   $ hg debugrename newdirname/newfile.py
   newdirname/newfile.py renamed from olddirname/newfile.py:690b295714aed510803d3020da9c70fca8336def
   $ hg status -C --change .
   A newdirname/newfile.py
   $ hg status -C --rev 1
   A newdirname/newfile.py
   $ hg status -C --rev 2
   A newdirname/commonfile.py
     olddirname/commonfile.py
   A newdirname/newfile.py
     olddirname/newfile.py
   R olddirname/commonfile.py
   R olddirname/newfile.py
   $ hg debugindex newdirname/newfile.py
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      89       3 34a4d536c0c0 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       3 34a4d536c0c0 000000000000 000000000000
 
   $ echo a >> newdirname/commonfile.py
   $ hg ci --amend -m bug
   $ hg debugrename newdirname/newfile.py
   newdirname/newfile.py renamed from olddirname/newfile.py:690b295714aed510803d3020da9c70fca8336def
   $ hg debugindex newdirname/newfile.py
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      89       3 34a4d536c0c0 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       3 34a4d536c0c0 000000000000 000000000000
 
 #if execbit
 
 Test if amend preserves executable bit changes
   $ chmod +x newdirname/commonfile.py
   $ hg ci -m chmod
   $ hg ci --amend -m "chmod amended"
   $ hg ci --amend -m "chmod amended second time"
   $ hg log -p --git -r .
   changeset:   7:b1326f52dddf
   branch:      newdirname
   tag:         tip
   parent:      4:7fd235f7cb2f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod amended second time
   
   diff --git a/newdirname/commonfile.py b/newdirname/commonfile.py
   old mode 100644
   new mode 100755
   
 #endif
 
 Test amend with file inclusion options
 --------------------------------------
 
 These tests ensure that we are always amending some files that were part of the
 pre-amend commit. We want to test that the remaining files in the pre-amend
 commit were not changed in the amended commit. We do so by performing a diff of
 the amended commit against its parent commit.
   $ cd ..
   $ hg init testfileinclusions
   $ cd testfileinclusions
   $ echo a > a
   $ echo b > b
   $ hg commit -Aqm "Adding a and b"
 
 Only add changes to a particular file
   $ echo a >> a
   $ echo b >> b
   $ hg commit --amend -I a
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +b
 
   $ echo a >> a
   $ hg commit --amend b
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,2 @@
   +b
   +b
 
 Exclude changes to a particular file
   $ echo b >> b
   $ hg commit --amend -X a
   $ hg diff --git -r null -r .
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,2 @@
   +a
   +a
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,3 @@
   +b
   +b
   +b
 
 Check the addremove flag
   $ echo c > c
   $ rm a
   $ hg commit --amend -A
   removing a
   adding c
   $ hg diff --git -r null -r .
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,3 @@
   +b
   +b
   +b
   diff --git a/c b/c
   new file mode 100644
   --- /dev/null
   +++ b/c
   @@ -0,0 +1,1 @@
   +c

tests/test-commit.t

@@ -1,833 +1,833 b''
 commit date test
 
   $ hg init test
   $ cd test
   $ echo foo > foo
   $ hg add foo
   $ cat > $TESTTMP/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg commit -m ""
   HGEDITFORM=commit.normal.normal
   abort: empty commit message
   [255]
   $ hg commit -d '0 0' -m commit-1
   $ echo foo >> foo
   $ hg commit -d '1 4444444' -m commit-3
   hg: parse error: impossible time zone offset: 4444444
   [255]
   $ hg commit -d '1	15.1' -m commit-4
   hg: parse error: invalid date: '1\t15.1'
   [255]
   $ hg commit -d 'foo bar' -m commit-5
   hg: parse error: invalid date: 'foo bar'
   [255]
   $ hg commit -d ' 1 4444' -m commit-6
   $ hg commit -d '111111111111 0' -m commit-7
   hg: parse error: date exceeds 32 bits: 111111111111
   [255]
   $ hg commit -d '-111111111111 0' -m commit-7
   hg: parse error: date exceeds 32 bits: -111111111111
   [255]
   $ echo foo >> foo
   $ hg commit -d '1901-12-13 20:45:52 +0000' -m commit-7-2
   $ echo foo >> foo
   $ hg commit -d '-2147483648 0' -m commit-7-3
   $ hg log -T '{rev} {date|isodatesec}\n' -l2
   3 1901-12-13 20:45:52 +0000
   2 1901-12-13 20:45:52 +0000
   $ hg commit -d '1901-12-13 20:45:51 +0000' -m commit-7
   hg: parse error: date exceeds 32 bits: -2147483649
   [255]
   $ hg commit -d '-2147483649 0' -m commit-7
   hg: parse error: date exceeds 32 bits: -2147483649
   [255]
 
 commit added file that has been deleted
 
   $ echo bar > bar
   $ hg add bar
   $ rm bar
   $ hg commit -m commit-8
   nothing changed (1 missing files, see 'hg status')
   [1]
   $ hg commit -m commit-8-2 bar
   abort: bar: file not found!
   [255]
 
   $ hg -q revert -a --no-backup
 
   $ mkdir dir
   $ echo boo > dir/file
   $ hg add
   adding dir/file
   $ hg -v commit -m commit-9 dir
   committing files:
   dir/file
   committing manifest
   committing changelog
   committed changeset 4:1957363f1ced
 
   $ echo > dir.file
   $ hg add
   adding dir.file
   $ hg commit -m commit-10 dir dir.file
   abort: dir: no match under directory!
   [255]
 
   $ echo >> dir/file
   $ mkdir bleh
   $ mkdir dir2
   $ cd bleh
   $ hg commit -m commit-11 .
   abort: bleh: no match under directory!
   [255]
   $ hg commit -m commit-12 ../dir ../dir2
   abort: dir2: no match under directory!
   [255]
   $ hg -v commit -m commit-13 ../dir
   committing files:
   dir/file
   committing manifest
   committing changelog
   committed changeset 5:a31d8f87544a
   $ cd ..
 
   $ hg commit -m commit-14 does-not-exist
   abort: does-not-exist: * (glob)
   [255]
 
 #if symlink
   $ ln -s foo baz
   $ hg commit -m commit-15 baz
   abort: baz: file not tracked!
   [255]
   $ rm baz
 #endif
 
   $ touch quux
   $ hg commit -m commit-16 quux
   abort: quux: file not tracked!
   [255]
   $ echo >> dir/file
   $ hg -v commit -m commit-17 dir/file
   committing files:
   dir/file
   committing manifest
   committing changelog
   committed changeset 6:32d054c9d085
 
 An empty date was interpreted as epoch origin
 
   $ echo foo >> foo
   $ hg commit -d '' -m commit-no-date --config devel.default-date=
   $ hg tip --template '{date|isodate}\n' | grep '1970'
   [1]
 
 Using the advanced --extra flag
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "commitextras=" >> $HGRCPATH
   $ hg status
   ? quux
   $ hg add quux
   $ hg commit -m "adding internal used extras" --extra amend_source=hash
   abort: key 'amend_source' is used internally, can't be set manually
   [255]
   $ hg commit -m "special chars in extra" --extra id@phab=214
   abort: keys can only contain ascii letters, digits, '_' and '-'
   [255]
   $ hg commit -m "empty key" --extra =value
   abort: unable to parse '=value', keys can't be empty
   [255]
   $ hg commit -m "adding extras" --extra sourcehash=foo --extra oldhash=bar
   $ hg log -r . -T '{extras % "{extra}\n"}'
   branch=default
   oldhash=bar
   sourcehash=foo
 
 Failed commit with --addremove should not update dirstate
 
   $ echo foo > newfile
   $ hg status
   ? newfile
   $ HGEDITOR=false hg ci --addremove
   adding newfile
   abort: edit failed: false exited with status 1
   [255]
   $ hg status
   ? newfile
 
 Make sure we do not obscure unknown requires file entries (issue2649)
 
   $ echo foo >> foo
   $ echo fake >> .hg/requires
   $ hg commit -m bla
   abort: repository requires features unknown to this Mercurial: fake!
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
 
   $ cd ..
 
 
 partial subdir commit test
 
   $ hg init test2
   $ cd test2
   $ mkdir foo
   $ echo foo > foo/foo
   $ mkdir bar
   $ echo bar > bar/bar
   $ hg add
   adding bar/bar
   adding foo/foo
   $ HGEDITOR=cat hg ci -e -m commit-subdir-1 foo
   commit-subdir-1
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added foo/foo
 
 
   $ hg ci -m commit-subdir-2 bar
 
 subdir log 1
 
   $ hg log -v foo
   changeset:   0:f97e73a25882
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo/foo
   description:
   commit-subdir-1
   
   
 
 subdir log 2
 
   $ hg log -v bar
   changeset:   1:aa809156d50d
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       bar/bar
   description:
   commit-subdir-2
   
   
 
 full log
 
   $ hg log -v
   changeset:   1:aa809156d50d
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       bar/bar
   description:
   commit-subdir-2
   
   
   changeset:   0:f97e73a25882
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo/foo
   description:
   commit-subdir-1
   
   
   $ cd ..
 
 
 dot and subdir commit test
 
   $ hg init test3
   $ echo commit-foo-subdir > commit-log-test
   $ cd test3
   $ mkdir foo
   $ echo foo content > foo/plain-file
   $ hg add foo/plain-file
   $ HGEDITOR=cat hg ci --edit -l ../commit-log-test foo
   commit-foo-subdir
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added foo/plain-file
 
 
   $ echo modified foo content > foo/plain-file
   $ hg ci -m commit-foo-dot .
 
 full log
 
   $ hg log -v
   changeset:   1:95b38e3a5b2e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo/plain-file
   description:
   commit-foo-dot
   
   
   changeset:   0:65d4e9386227
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo/plain-file
   description:
   commit-foo-subdir
   
   
 
 subdir log
 
   $ cd foo
   $ hg log .
   changeset:   1:95b38e3a5b2e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit-foo-dot
   
   changeset:   0:65d4e9386227
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commit-foo-subdir
   
   $ cd ..
   $ cd ..
 
 Issue1049: Hg permits partial commit of merge without warning
 
   $ hg init issue1049
   $ cd issue1049
   $ echo a > a
   $ hg ci -Ama
   adding a
   $ echo a >> a
   $ hg ci -mb
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b >> a
   $ hg ci -mc
   created new head
   $ HGMERGE=true hg merge
   merging a
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 should fail because we are specifying a file name
 
   $ hg ci -mmerge a
   abort: cannot partially commit a merge (do not specify files or patterns)
   [255]
 
 should fail because we are specifying a pattern
 
   $ hg ci -mmerge -I a
   abort: cannot partially commit a merge (do not specify files or patterns)
   [255]
 
 should succeed
 
   $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg ci -mmerge --edit
   HGEDITFORM=commit.normal.merge
   $ cd ..
 
 
 test commit message content
 
   $ hg init commitmsg
   $ cd commitmsg
   $ echo changed > changed
   $ echo removed > removed
   $ hg book activebookmark
   $ hg ci -qAm init
 
   $ hg rm removed
   $ echo changed >> changed
   $ echo added > added
   $ hg add added
   $ HGEDITOR=cat hg ci -A
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: bookmark 'activebookmark'
   HG: added added
   HG: changed changed
   HG: removed removed
   abort: empty commit message
   [255]
 
 test saving last-message.txt
 
   $ hg init sub
   $ echo a > sub/a
   $ hg -R sub add sub/a
   $ cat > sub/.hg/hgrc <<EOF
   > [hooks]
   > precommit.test-saving-last-message = false
   > EOF
 
   $ echo 'sub = sub' > .hgsub
   $ hg add .hgsub
 
   $ cat > $TESTTMP/editor.sh <<EOF
   > echo "==== before editing:"
   > cat \$1
   > echo "===="
   > echo "test saving last-message.txt" >> \$1
   > EOF
 
   $ rm -f .hg/last-message.txt
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg commit -S -q
   ==== before editing:
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: bookmark 'activebookmark'
   HG: subrepo sub
   HG: added .hgsub
   HG: added added
   HG: changed .hgsubstate
   HG: changed changed
   HG: removed removed
   ====
   abort: precommit.test-saving-last-message hook exited with status 1 (in subrepository "sub")
   [255]
   $ cat .hg/last-message.txt
   
   
   test saving last-message.txt
 
 test that '[committemplate] changeset' definition and commit log
 specific template keywords work well
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit.normal = 'HG: this is "commit.normal" template
   >     HG: {extramsg}
   >     {if(activebookmark,
   >    "HG: bookmark '{activebookmark}' is activated\n",
   >    "HG: no bookmark is activated\n")}{subrepos %
   >    "HG: subrepo '{subrepo}' is changed\n"}'
   > 
   > changeset.commit = HG: this is "commit" template
   >     HG: {extramsg}
   >     {if(activebookmark,
   >    "HG: bookmark '{activebookmark}' is activated\n",
   >    "HG: no bookmark is activated\n")}{subrepos %
   >    "HG: subrepo '{subrepo}' is changed\n"}
   > 
   > changeset = HG: this is customized commit template
   >     HG: {extramsg}
   >     {if(activebookmark,
   >    "HG: bookmark '{activebookmark}' is activated\n",
   >    "HG: no bookmark is activated\n")}{subrepos %
   >    "HG: subrepo '{subrepo}' is changed\n"}
   > EOF
 
   $ hg init sub2
   $ echo a > sub2/a
   $ hg -R sub2 add sub2/a
   $ echo 'sub2 = sub2' >> .hgsub
 
   $ HGEDITOR=cat hg commit -S -q
   HG: this is "commit.normal" template
   HG: Leave message empty to abort commit.
   HG: bookmark 'activebookmark' is activated
   HG: subrepo 'sub' is changed
   HG: subrepo 'sub2' is changed
   abort: empty commit message
   [255]
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit.normal =
   > # now, "changeset.commit" should be chosen for "hg commit"
   > EOF
 
   $ hg bookmark --inactive activebookmark
   $ hg forget .hgsub
   $ HGEDITOR=cat hg commit -q
   HG: this is "commit" template
   HG: Leave message empty to abort commit.
   HG: no bookmark is activated
   abort: empty commit message
   [255]
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit =
   > # now, "changeset" should be chosen for "hg commit"
   > EOF
 
   $ HGEDITOR=cat hg commit -q
   HG: this is customized commit template
   HG: Leave message empty to abort commit.
   HG: no bookmark is activated
   abort: empty commit message
   [255]
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset = {desc}
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}
   >     HG:
   >     {splitlines(diff()) % 'HG: {line}\n'
   >    }HG:
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}\n
   > EOF
   $ hg status -amr
   M changed
   A added
   R removed
   $ HGEDITOR=cat hg commit -q -e -m "foo bar" changed
   foo bar
   HG: mods=changed
   HG: adds=
   HG: dels=
   HG: files=changed
   HG:
   HG: --- a/changed	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/changed	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +1,2 @@
   HG:  changed
   HG: +changed
   HG:
   HG: mods=changed
   HG: adds=
   HG: dels=
   HG: files=changed
   $ hg status -amr
   A added
   R removed
   $ hg parents --template "M {file_mods}\nA {file_adds}\nR {file_dels}\n"
   M changed
   A 
   R 
   $ hg rollback -q
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset = {desc}
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}
   >     HG:
   >     {splitlines(diff("changed")) % 'HG: {line}\n'
   >    }HG:
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}
   >     HG:
   >     {splitlines(diff("added")) % 'HG: {line}\n'
   >    }HG:
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}
   >     HG:
   >     {splitlines(diff("removed")) % 'HG: {line}\n'
   >    }HG:
   >     HG: mods={file_mods}
   >     HG: adds={file_adds}
   >     HG: dels={file_dels}
   >     HG: files={files}\n
   > EOF
   $ HGEDITOR=cat hg commit -q -e -m "foo bar" added removed
   foo bar
   HG: mods=
   HG: adds=added
   HG: dels=removed
   HG: files=added removed
   HG:
   HG:
   HG: mods=
   HG: adds=added
   HG: dels=removed
   HG: files=added removed
   HG:
   HG: --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ b/added	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -0,0 +1,1 @@
   HG: +added
   HG:
   HG: mods=
   HG: adds=added
   HG: dels=removed
   HG: files=added removed
   HG:
   HG: --- a/removed	Thu Jan 01 00:00:00 1970 +0000
   HG: +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   HG: @@ -1,1 +0,0 @@
   HG: -removed
   HG:
   HG: mods=
   HG: adds=added
   HG: dels=removed
   HG: files=added removed
   $ hg status -amr
   M changed
   $ hg parents --template "M {file_mods}\nA {file_adds}\nR {file_dels}\n"
   M 
   A added
   R removed
   $ hg rollback -q
 
   $ cat >> .hg/hgrc <<EOF
   > # disable customizing for subsequent tests
   > [committemplate]
   > changeset =
   > EOF
 
   $ cd ..
 
 
 commit copy
 
   $ hg init dir2
   $ cd dir2
   $ echo bleh > bar
   $ hg add bar
   $ hg ci -m 'add bar'
 
   $ hg cp bar foo
   $ echo >> bar
   $ hg ci -m 'cp bar foo; change bar'
 
   $ hg debugrename foo
   foo renamed from bar:26d3ca0dfd18e44d796b564e38dd173c9668d3a9
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       6       0 26d3ca0dfd18 000000000000 000000000000
-       1         6       7       1 d267bddd54f7 26d3ca0dfd18 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 26d3ca0dfd18 000000000000 000000000000
+       1       1 d267bddd54f7 26d3ca0dfd18 000000000000
 
 Test making empty commits
   $ hg commit --config ui.allowemptycommit=True -m "empty commit"
   $ hg log -r . -v --stat
   changeset:   2:d809f3644287
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   description:
   empty commit
   
   
   
 verify pathauditor blocks evil filepaths
   $ cat > evil-commit.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import context, hg, node, ui as uimod
   > notrc = u".h\u200cg".encode('utf-8') + b'/hgrc'
   > u = uimod.ui.load()
   > r = hg.repository(u, b'.')
   > def filectxfn(repo, memctx, path):
   >     return context.memfilectx(repo, memctx, path,
   >         b'[hooks]\nupdate = echo owned')
   > c = context.memctx(r, [r[b'tip'].node(), node.nullid],
   >                    b'evil', [notrc], filectxfn, 0)
   > r.commitctx(c)
   > EOF
   $ $PYTHON evil-commit.py
 #if windows
   $ hg co --clean tip
   abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc)
   [255]
 #else
   $ hg co --clean tip
   abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc)
   [255]
 #endif
 
   $ hg rollback -f
   repository tip rolled back to revision 2 (undo commit)
   $ cat > evil-commit.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import context, hg, node, ui as uimod
   > notrc = b"HG~1/hgrc"
   > u = uimod.ui.load()
   > r = hg.repository(u, b'.')
   > def filectxfn(repo, memctx, path):
   >     return context.memfilectx(repo, memctx, path,
   >         b'[hooks]\nupdate = echo owned')
   > c = context.memctx(r, [r[b'tip'].node(), node.nullid],
   >                    b'evil', [notrc], filectxfn, 0)
   > r.commitctx(c)
   > EOF
   $ $PYTHON evil-commit.py
   $ hg co --clean tip
   abort: path contains illegal component: HG~1/hgrc
   [255]
 
   $ hg rollback -f
   repository tip rolled back to revision 2 (undo commit)
   $ cat > evil-commit.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import context, hg, node, ui as uimod
   > notrc = b"HG8B6C~2/hgrc"
   > u = uimod.ui.load()
   > r = hg.repository(u, b'.')
   > def filectxfn(repo, memctx, path):
   >     return context.memfilectx(repo, memctx, path,
   >         b'[hooks]\nupdate = echo owned')
   > c = context.memctx(r, [r[b'tip'].node(), node.nullid],
   >                    b'evil', [notrc], filectxfn, 0)
   > r.commitctx(c)
   > EOF
   $ $PYTHON evil-commit.py
   $ hg co --clean tip
   abort: path contains illegal component: HG8B6C~2/hgrc
   [255]
 
 # test that an unmodified commit template message aborts
 
   $ hg init unmodified_commit_template
   $ cd unmodified_commit_template
   $ echo foo > foo
   $ hg add foo
   $ hg commit -m "foo"
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit = HI THIS IS NOT STRIPPED
   >     HG: this is customized commit template
   >     HG: {extramsg}
   >     {if(activebookmark,
   >    "HG: bookmark '{activebookmark}' is activated\n",
   >    "HG: no bookmark is activated\n")}{subrepos %
   >    "HG: subrepo '{subrepo}' is changed\n"}
   > EOF
   $ cat > $TESTTMP/notouching.sh <<EOF
   > true
   > EOF
   $ echo foo2 > foo2
   $ hg add foo2
   $ HGEDITOR="sh $TESTTMP/notouching.sh" hg commit
   abort: commit message unchanged
   [255]
 
 test that text below the --- >8 --- special string is ignored
 
   $ cat <<'EOF' > $TESTTMP/lowercaseline.sh
   > cat $1 | sed s/LINE/line/ | tee $1.new
   > mv $1.new $1
   > EOF
 
   $ hg init ignore_below_special_string
   $ cd ignore_below_special_string
   $ echo foo > foo
   $ hg add foo
   $ hg commit -m "foo"
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit = first LINE
   >     HG: this is customized commit template
   >     HG: {extramsg}
   >     HG: ------------------------ >8 ------------------------
   >     {diff()}
   > EOF
   $ echo foo2 > foo2
   $ hg add foo2
   $ HGEDITOR="sh $TESTTMP/notouching.sh" hg ci
   abort: commit message unchanged
   [255]
   $ HGEDITOR="sh $TESTTMP/lowercaseline.sh" hg ci
   first line
   HG: this is customized commit template
   HG: Leave message empty to abort commit.
   HG: ------------------------ >8 ------------------------
   diff -r e63c23eaa88a foo2
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/foo2	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +foo2
   $ hg log -T '{desc}\n' -r .
   first line
 
 test that the special string --- >8 --- isn't used when not at the beginning of
 a line
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit = first LINE2
   >     another line HG: ------------------------ >8 ------------------------
   >     HG: this is customized commit template
   >     HG: {extramsg}
   >     HG: ------------------------ >8 ------------------------
   >     {diff()}
   > EOF
   $ echo foo >> foo
   $ HGEDITOR="sh $TESTTMP/lowercaseline.sh" hg ci
   first line2
   another line HG: ------------------------ >8 ------------------------
   HG: this is customized commit template
   HG: Leave message empty to abort commit.
   HG: ------------------------ >8 ------------------------
   diff -r 3661b22b0702 foo
   --- a/foo	Thu Jan 01 00:00:00 1970 +0000
   +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    foo
   +foo
   $ hg log -T '{desc}\n' -r .
   first line2
   another line HG: ------------------------ >8 ------------------------
 
 also test that this special string isn't accepted when there is some extra text
 at the end
 
   $ cat >> .hg/hgrc <<EOF
   > [committemplate]
   > changeset.commit = first LINE3
   >     HG: ------------------------ >8 ------------------------foobar
   >     second line
   >     HG: this is customized commit template
   >     HG: {extramsg}
   >     HG: ------------------------ >8 ------------------------
   >     {diff()}
   > EOF
   $ echo foo >> foo
   $ HGEDITOR="sh $TESTTMP/lowercaseline.sh" hg ci
   first line3
   HG: ------------------------ >8 ------------------------foobar
   second line
   HG: this is customized commit template
   HG: Leave message empty to abort commit.
   HG: ------------------------ >8 ------------------------
   diff -r ce648f5f066f foo
   --- a/foo	Thu Jan 01 00:00:00 1970 +0000
   +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,2 +1,3 @@
    foo
    foo
   +foo
   $ hg log -T '{desc}\n' -r .
   first line3
   second line
 
   $ cd ..

tests/test-copy.t

@@ -1,250 +1,250 b''
 # enable bundle2 in advance
 
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usegeneraldelta=yes
   > EOF
 
   $ mkdir part1
   $ cd part1
 
   $ hg init
   $ echo a > a
   $ hg add a
   $ hg commit -m "1"
   $ hg status
   $ hg copy a b
   $ hg --config ui.portablefilenames=abort copy a con.xml
   abort: filename contains 'con', which is reserved on Windows: con.xml
   [255]
   $ hg status
   A b
   $ hg sum
   parent: 0:c19d34741b0a tip
    1
   branch: default
   commit: 1 copied
   update: (current)
   phases: 1 draft
   $ hg --debug commit -m "2"
   committing files:
   b
    b: copy a:b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
   committing manifest
   committing changelog
   updating the branch cache
   committed changeset 1:93580a2c28a50a56f63526fb305067e6fbf739c4
 
 we should see two history entries
 
   $ hg history -v
   changeset:   1:93580a2c28a5
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       b
   description:
   2
   
   
   changeset:   0:c19d34741b0a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   description:
   1
   
   
 
 we should see one log entry for a
 
   $ hg log a
   changeset:   0:c19d34741b0a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
 
 this should show a revision linked to changeset 0
 
   $ hg debugindex a
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b789fdd96dc2 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b789fdd96dc2 000000000000 000000000000
 
 we should see one log entry for b
 
   $ hg log b
   changeset:   1:93580a2c28a5
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 
 this should show a revision linked to changeset 1
 
   $ hg debugindex b
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      65       1 37d9b5d994ea 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       1 37d9b5d994ea 000000000000 000000000000
 
 this should show the rename information in the metadata
 
   $ hg debugdata b 0 | head -3 | tail -2
   copy: a
   copyrev: b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
 
   $ md5sum.py .hg/store/data/b.i
   44913824c8f5890ae218f9829535922e  .hg/store/data/b.i
   $ hg cat b > bsum
   $ md5sum.py bsum
   60b725f10c9c85c70d97880dfe8191b3  bsum
   $ hg cat a > asum
   $ md5sum.py asum
   60b725f10c9c85c70d97880dfe8191b3  asum
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
 
   $ cd ..
 
 
   $ mkdir part2
   $ cd part2
 
   $ hg init
   $ echo foo > foo
 should fail - foo is not managed
   $ hg mv foo bar
   foo: not copying - file is not managed
   abort: no files to copy
   [255]
   $ hg st -A
   ? foo
   $ hg add foo
 dry-run; print a warning that this is not a real copy; foo is added
   $ hg mv --dry-run foo bar
   foo has not been committed yet, so no copy data will be stored for bar.
   $ hg st -A
   A foo
 should print a warning that this is not a real copy; bar is added
   $ hg mv foo bar
   foo has not been committed yet, so no copy data will be stored for bar.
   $ hg st -A
   A bar
 should print a warning that this is not a real copy; foo is added
   $ hg cp bar foo
   bar has not been committed yet, so no copy data will be stored for foo.
   $ hg rm -f bar
   $ rm bar
   $ hg st -A
   A foo
   $ hg commit -m1
 
 moving a missing file
   $ rm foo
   $ hg mv foo foo3
   foo: deleted in working directory
   foo3 does not exist!
   $ hg up -qC .
 
 copy --after to a nonexistent target filename
   $ hg cp -A foo dummy
   foo: not recording copy - dummy does not exist
 
 dry-run; should show that foo is clean
   $ hg copy --dry-run foo bar
   $ hg st -A
   C foo
 should show copy
   $ hg copy foo bar
   $ hg st -C
   A bar
     foo
 
 shouldn't show copy
   $ hg commit -m2
   $ hg st -C
 
 should match
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       5       0 2ed2a3912a0b 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 2ed2a3912a0b 000000000000 000000000000
   $ hg debugrename bar
   bar renamed from foo:2ed2a3912a0b24502043eae84ee4b279c18b90dd
 
   $ echo bleah > foo
   $ echo quux > bar
   $ hg commit -m3
 
 should not be renamed
   $ hg debugrename bar
   bar not renamed
 
   $ hg copy -f foo bar
 should show copy
   $ hg st -C
   M bar
     foo
 
 XXX: filtering lfilesrepo.status() in 3.3-rc causes the copy source to not be
 displayed.
   $ hg st -C --config extensions.largefiles=
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   M bar
     foo
 
   $ hg commit -m3
 
 should show no parents for tip
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      69       1 7711d36246cc 000000000000 000000000000
-       1        69       6       2 bdf70a2b8d03 7711d36246cc 000000000000
-       2        75      71       3 b2558327ea8d 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       1 7711d36246cc 000000000000 000000000000
+       1       2 bdf70a2b8d03 7711d36246cc 000000000000
+       2       3 b2558327ea8d 000000000000 000000000000
 should match
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       5       0 2ed2a3912a0b 000000000000 000000000000
-       1         5       7       2 dd12c926cf16 2ed2a3912a0b 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 2ed2a3912a0b 000000000000 000000000000
+       1       2 dd12c926cf16 2ed2a3912a0b 000000000000
   $ hg debugrename bar
   bar renamed from foo:dd12c926cf165e3eb4cf87b084955cb617221c17
 
 should show no copies
   $ hg st -C
 
 copy --after on an added file
   $ cp bar baz
   $ hg add baz
   $ hg cp -A bar baz
   $ hg st -C
   A baz
     bar
 
 foo was clean:
   $ hg st -AC foo
   C foo
 Trying to copy on top of an existing file fails,
   $ hg copy -A bar foo
   foo: not overwriting - file already committed
   (hg copy --after --force to replace the file by recording a copy)
 same error without the --after, so the user doesn't have to go through
 two hints:
   $ hg copy bar foo
   foo: not overwriting - file already committed
   (hg copy --force to replace the file by recording a copy)
 but it's considered modified after a copy --after --force
   $ hg copy -Af bar foo
   $ hg st -AC foo
   M foo
     bar
 The hint for a file that exists but is not in file history doesn't
 mention --force:
   $ touch xyzzy
   $ hg cp bar xyzzy
   xyzzy: not overwriting - file exists
   (hg copy --after to record the copy)
 
   $ cd ..

tests/test-debugcommands.t

@@ -1,406 +1,417 b''
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > interactive=yes
   > [format]
   > usegeneraldelta=yes
   > EOF
 
   $ hg init debugrevlog
   $ cd debugrevlog
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ hg debugrevlog -m
   format : 1
   flags  : inline, generaldelta
   
   revisions     :  1
       merges    :  0 ( 0.00%)
       normal    :  1 (100.00%)
   revisions     :  1
       full      :  1 (100.00%)
       deltas    :  0 ( 0.00%)
   revision size : 44
       full      : 44 (100.00%)
       deltas    :  0 ( 0.00%)
   
   chunks        :  1
       0x75 (u)  :  1 (100.00%)
   chunks size   : 44
       0x75 (u)  : 44 (100.00%)
   
   avg chain length  :  0
   max chain length  :  0
   max chain reach   : 44
   compression ratio :  0
   
   uncompressed data size (min/max/avg) : 43 / 43 / 43
   full revision size (min/max/avg)     : 44 / 44 / 44
   delta size (min/max/avg)             : 0 / 0 / 0
 
-Test debugindex, with and without the --debug flag
+Test debugindex, with and without the --verbose/--debug flag
   $ hg debugindex a
+     rev linkrev nodeid       p1           p2
+       0       0 b789fdd96dc2 000000000000 000000000000
+
+  $ hg --verbose debugindex a
      rev    offset  length linkrev nodeid       p1           p2
        0         0       3       0 b789fdd96dc2 000000000000 000000000000
+
   $ hg --debug debugindex a
      rev    offset  length linkrev nodeid                                   p1                                       p2
        0         0       3       0 b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000
+
   $ hg debugindex -f 1 a
+     rev flag     size   link     p1     p2       nodeid
+       0 0000        2      0     -1     -1 b789fdd96dc2
+
+  $ hg --verbose debugindex -f 1 a
      rev flag   offset   length     size   link     p1     p2       nodeid
        0 0000        0        3        2      0     -1     -1 b789fdd96dc2
+
   $ hg --debug debugindex -f 1 a
      rev flag   offset   length     size   link     p1     p2                                   nodeid
        0 0000        0        3        2      0     -1     -1 b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3
 
 debugdelta chain basic output
 
   $ hg debugdeltachain -m
       rev  chain# chainlen     prev   delta       size    rawsize  chainsize     ratio   lindist extradist extraratio
         0       1        1       -1    base         44         43         44   1.02326        44         0    0.00000
 
   $ hg debugdeltachain -m -T '{rev} {chainid} {chainlen}\n'
   0 1 1
 
   $ hg debugdeltachain -m -Tjson
   [
    {
     "chainid": 1,
     "chainlen": 1,
     "chainratio": 1.02325581395,
     "chainsize": 44,
     "compsize": 44,
     "deltatype": "base",
     "extradist": 0,
     "extraratio": 0.0,
     "lindist": 44,
     "prevrev": -1,
     "rev": 0,
     "uncompsize": 43
    }
   ]
 
 debugdelta chain with sparse read enabled
 
   $ cat >> $HGRCPATH <<EOF
   > [experimental]
   > sparse-read = True
   > EOF
   $ hg debugdeltachain -m
       rev  chain# chainlen     prev   delta       size    rawsize  chainsize     ratio   lindist extradist extraratio   readsize largestblk rddensity srchunks
         0       1        1       -1    base         44         43         44   1.02326        44         0    0.00000         44         44   1.00000        1
 
   $ hg debugdeltachain -m -T '{rev} {chainid} {chainlen} {readsize} {largestblock} {readdensity}\n'
   0 1 1 44 44 1.0
 
   $ hg debugdeltachain -m -Tjson
   [
    {
     "chainid": 1,
     "chainlen": 1,
     "chainratio": 1.02325581395,
     "chainsize": 44,
     "compsize": 44,
     "deltatype": "base",
     "extradist": 0,
     "extraratio": 0.0,
     "largestblock": 44,
     "lindist": 44,
     "prevrev": -1,
     "readdensity": 1.0,
     "readsize": 44,
     "rev": 0,
     "srchunks": 1,
     "uncompsize": 43
    }
   ]
 
   $ printf "This test checks things.\n" >> a
   $ hg ci -m a
   $ hg branch other
   marked working directory as branch other
   (branches are permanent and global, did you want a bookmark?)
   $ for i in `$TESTDIR/seq.py 5`; do
   >   printf "shorter ${i}" >> a
   >   hg ci -m "a other:$i"
   >   hg up -q default
   >   printf "for the branch default we want longer chains: ${i}" >> a
   >   hg ci -m "a default:$i"
   >   hg up -q other
   > done
   $ hg debugdeltachain a -T '{rev} {srchunks}\n' \
   >    --config experimental.sparse-read.density-threshold=0.50 \
   >    --config experimental.sparse-read.min-gap-size=0
   0 1
   1 1
   2 1
   3 1
   4 1
   5 1
   6 1
   7 1
   8 1
   9 1
   10 2
   11 1
   $ hg --config extensions.strip= strip --no-backup -r 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test max chain len
   $ cat >> $HGRCPATH << EOF
   > [format]
   > maxchainlen=4
   > EOF
 
   $ printf "This test checks if maxchainlen config value is respected also it can serve as basic test for debugrevlog -d <file>.\n" >> a
   $ hg ci -m a
   $ printf "b\n" >> a
   $ hg ci -m a
   $ printf "c\n" >> a
   $ hg ci -m a
   $ printf "d\n" >> a
   $ hg ci -m a
   $ printf "e\n" >> a
   $ hg ci -m a
   $ printf "f\n" >> a
   $ hg ci -m a
   $ printf 'g\n' >> a
   $ hg ci -m a
   $ printf 'h\n' >> a
   $ hg ci -m a
   $ hg debugrevlog -d a
   # rev p1rev p2rev start   end deltastart base   p1   p2 rawsize totalsize compression heads chainlen
       0    -1    -1     0   ???          0    0    0    0     ???      ????           ?     1        0 (glob)
       1     0    -1   ???   ???          0    0    0    0     ???      ????           ?     1        1 (glob)
       2     1    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        2 (glob)
       3     2    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        3 (glob)
       4     3    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        4 (glob)
       5     4    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        0 (glob)
       6     5    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        1 (glob)
       7     6    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        2 (glob)
       8     7    -1   ???   ???        ???  ???  ???    0     ???      ????           ?     1        3 (glob)
 
 Test debuglocks command:
 
   $ hg debuglocks
   lock:  free
   wlock: free
 
 * Test setting the lock
 
 waitlock <file> will wait for file to be created. If it isn't in a reasonable
 amount of time, displays error message and returns 1
   $ waitlock() {
   >     start=`date +%s`
   >     timeout=5
   >     while [ \( ! -f $1 \) -a \( ! -L $1 \) ]; do
   >         now=`date +%s`
   >         if [ "`expr $now - $start`" -gt $timeout ]; then
   >             echo "timeout: $1 was not created in $timeout seconds"
   >             return 1
   >         fi
   >         sleep 0.1
   >     done
   > }
   $ dolock() {
   >     {
   >         waitlock .hg/unlock
   >         rm -f .hg/unlock
   >         echo y
   >     } | hg debuglocks "$@" > /dev/null
   > }
   $ dolock -s &
   $ waitlock .hg/store/lock
 
   $ hg debuglocks
   lock:  user *, process * (*s) (glob)
   wlock: free
   [1]
   $ touch .hg/unlock
   $ wait
   $ [ -f .hg/store/lock ] || echo "There is no lock"
   There is no lock
 
 * Test setting the wlock
 
   $ dolock -S &
   $ waitlock .hg/wlock
 
   $ hg debuglocks
   lock:  free
   wlock: user *, process * (*s) (glob)
   [1]
   $ touch .hg/unlock
   $ wait
   $ [ -f .hg/wlock ] || echo "There is no wlock"
   There is no wlock
 
 * Test setting both locks
 
   $ dolock -Ss &
   $ waitlock .hg/wlock && waitlock .hg/store/lock
 
   $ hg debuglocks
   lock:  user *, process * (*s) (glob)
   wlock: user *, process * (*s) (glob)
   [2]
 
 * Test failing to set a lock
 
   $ hg debuglocks -s
   abort: lock is already held
   [255]
 
   $ hg debuglocks -S
   abort: wlock is already held
   [255]
 
   $ touch .hg/unlock
   $ wait
 
   $ hg debuglocks
   lock:  free
   wlock: free
 
 * Test forcing the lock
 
   $ dolock -s &
   $ waitlock .hg/store/lock
 
   $ hg debuglocks
   lock:  user *, process * (*s) (glob)
   wlock: free
   [1]
 
   $ hg debuglocks -L
 
   $ hg debuglocks
   lock:  free
   wlock: free
 
   $ touch .hg/unlock
   $ wait
 
 * Test forcing the wlock
 
   $ dolock -S &
   $ waitlock .hg/wlock
 
   $ hg debuglocks
   lock:  free
   wlock: user *, process * (*s) (glob)
   [1]
 
   $ hg debuglocks -W
 
   $ hg debuglocks
   lock:  free
   wlock: free
 
   $ touch .hg/unlock
   $ wait
 
 Test WdirUnsupported exception
 
   $ hg debugdata -c ffffffffffffffffffffffffffffffffffffffff
   abort: working directory revision cannot be specified
   [255]
 
 Test cache warming command
 
   $ rm -rf .hg/cache/
   $ hg debugupdatecaches --debug
   updating the branch cache
   $ ls -r .hg/cache/*
   .hg/cache/rbc-revs-v1
   .hg/cache/rbc-names-v1
   .hg/cache/branch2-served
 
   $ cd ..
 
 Test internal debugstacktrace command
 
   $ cat > debugstacktrace.py << EOF
   > from __future__ import absolute_import
   > import sys
   > from mercurial import util
   > def f():
   >     util.debugstacktrace(f=sys.stdout)
   >     g()
   > def g():
   >     util.dst('hello from g\\n', skip=1)
   >     h()
   > def h():
   >     util.dst('hi ...\\nfrom h hidden in g', 1, depth=2)
   > f()
   > EOF
   $ $PYTHON debugstacktrace.py
   stacktrace at:
    debugstacktrace.py:12 in * (glob)
    debugstacktrace.py:5  in f
   hello from g at:
    debugstacktrace.py:12 in * (glob)
    debugstacktrace.py:6  in f
   hi ...
   from h hidden in g at:
    debugstacktrace.py:6 in f
    debugstacktrace.py:9 in g
 
 Test debugcapabilities command:
 
   $ hg debugcapabilities ./debugrevlog/
   Main capabilities:
     branchmap
     $USUAL_BUNDLE2_CAPS$
     getbundle
     known
     lookup
     pushkey
     unbundle
   Bundle2 capabilities:
     HG20
     bookmarks
     changegroup
       01
       02
     digests
       md5
       sha1
       sha512
     error
       abort
       unsupportedcontent
       pushraced
       pushkey
     hgtagsfnodes
     listkeys
     phases
       heads
     pushkey
     remote-changegroup
       http
       https
     rev-branch-cache
     stream
       v2
 
 Test debugpeer
 
   $ hg --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" debugpeer ssh://user@dummy/debugrevlog
   url: ssh://user@dummy/debugrevlog
   local: no
   pushable: yes
 
   $ hg --config ui.ssh="\"$PYTHON\" \"$TESTDIR/dummyssh\"" --debug debugpeer ssh://user@dummy/debugrevlog
   running "*" "*/tests/dummyssh" 'user@dummy' 'hg -R debugrevlog serve --stdio' (glob) (no-windows !)
   running "*" "*\tests/dummyssh" "user@dummy" "hg -R debugrevlog serve --stdio" (glob) (windows !)
   devel-peer-request: hello
   sending hello command
   devel-peer-request: between
   devel-peer-request:   pairs: 81 bytes
   sending between command
   remote: 403
   remote: capabilities: lookup branchmap pushkey known getbundle unbundlehash changegroupsubset streamreqs=generaldelta,revlogv1 $USUAL_BUNDLE2_CAPS_SERVER$ unbundle=HG10GZ,HG10BZ,HG10UN batch
   remote: 1
   url: ssh://user@dummy/debugrevlog
   local: no
   pushable: yes

tests/test-excessive-merge.t

@@ -1,101 +1,101 b''
   $ hg init
 
   $ echo foo > a
   $ echo foo > b
   $ hg add a b
 
   $ hg ci -m "test"
 
   $ echo blah > a
 
   $ hg ci -m "branch a"
 
   $ hg co 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ echo blah > b
 
   $ hg ci -m "branch b"
   created new head
   $ HGMERGE=true hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg ci -m "merge b/a -> blah"
 
   $ hg co 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ HGMERGE=true hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m "merge a/b -> blah"
   created new head
 
   $ hg log
   changeset:   4:2ee31f665a86
   tag:         tip
   parent:      1:96155394af80
   parent:      2:92cc4c306b19
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge a/b -> blah
   
   changeset:   3:e16a66a37edd
   parent:      2:92cc4c306b19
   parent:      1:96155394af80
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     merge b/a -> blah
   
   changeset:   2:92cc4c306b19
   parent:      0:5e0375449e74
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     branch b
   
   changeset:   1:96155394af80
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     branch a
   
   changeset:   0:5e0375449e74
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
   $ hg debugindex --changelog
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      60       0 5e0375449e74 000000000000 000000000000
-       1        60      62       1 96155394af80 5e0375449e74 000000000000
-       2       122      62       2 92cc4c306b19 5e0375449e74 000000000000
-       3       184      69       3 e16a66a37edd 92cc4c306b19 96155394af80
-       4       253      69       4 2ee31f665a86 96155394af80 92cc4c306b19
+     rev linkrev nodeid       p1           p2
+       0       0 5e0375449e74 000000000000 000000000000
+       1       1 96155394af80 5e0375449e74 000000000000
+       2       2 92cc4c306b19 5e0375449e74 000000000000
+       3       3 e16a66a37edd 92cc4c306b19 96155394af80
+       4       4 2ee31f665a86 96155394af80 92cc4c306b19
 
 revision 1
   $ hg manifest --debug 1
   79d7492df40aa0fa093ec4209be78043c181f094 644   a
   2ed2a3912a0b24502043eae84ee4b279c18b90dd 644   b
 revision 2
   $ hg manifest --debug 2
   2ed2a3912a0b24502043eae84ee4b279c18b90dd 644   a
   79d7492df40aa0fa093ec4209be78043c181f094 644   b
 revision 3
   $ hg manifest --debug 3
   79d7492df40aa0fa093ec4209be78043c181f094 644   a
   79d7492df40aa0fa093ec4209be78043c181f094 644   b
 revision 4
   $ hg manifest --debug 4
   79d7492df40aa0fa093ec4209be78043c181f094 644   a
   79d7492df40aa0fa093ec4209be78043c181f094 644   b
 
   $ hg debugindex a
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       5       0 2ed2a3912a0b 000000000000 000000000000
-       1         5       6       1 79d7492df40a 2ed2a3912a0b 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 2ed2a3912a0b 000000000000 000000000000
+       1       1 79d7492df40a 2ed2a3912a0b 000000000000
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 5 changesets, 4 total revisions

tests/test-extra-filelog-entry.t

@@ -1,21 +1,21 b''
 Issue351: mq: qrefresh can create extra revlog entry
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
 
   $ hg init
   $ hg qinit
 
   $ echo b > b
   $ hg ci -A -m foo
   adding b
 
   $ echo cc > b
   $ hg qnew -f foo.diff
   $ echo b > b
   $ hg qrefresh
 
   $ hg debugindex b
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 1e88685f5dde 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 1e88685f5dde 000000000000 000000000000
 

tests/test-filebranch.t

@@ -1,146 +1,146 b''
 This test makes sure that we don't mark a file as merged with its ancestor
 when we do a merge.
 
   $ cat <<EOF > merge
   > from __future__ import print_function
   > import sys, os
   > print("merging for", os.path.basename(sys.argv[1]))
   > EOF
   $ HGMERGE="$PYTHON ../merge"; export HGMERGE
 
 Creating base:
 
   $ hg init a
   $ cd a
   $ echo 1 > foo
   $ echo 1 > bar
   $ echo 1 > baz
   $ echo 1 > quux
   $ hg add foo bar baz quux
   $ hg commit -m "base"
 
   $ cd ..
   $ hg clone a b
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Creating branch a:
 
   $ cd a
   $ echo 2a > foo
   $ echo 2a > bar
   $ hg commit -m "branch a"
 
 Creating branch b:
 
   $ cd ..
   $ cd b
   $ echo 2b > foo
   $ echo 2b > baz
   $ hg commit -m "branch b"
 
 We shouldn't have anything but n state here:
 
   $ hg debugstate --nodates | grep -v "^n"
   [1]
 
 Merging:
 
   $ hg pull ../a
   pulling from ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files (+1 heads)
   new changesets bdd988058d16
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
   $ hg merge -v
   resolving manifests
   getting bar
   merging foo
   merging for foo
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ echo 2m > foo
   $ echo 2b > baz
   $ echo new > quux
 
   $ hg ci -m "merge"
 
 main: we should have a merge here:
 
   $ hg debugindex --changelog
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      73       0 cdca01651b96 000000000000 000000000000
-       1        73      68       1 f6718a9cb7f3 cdca01651b96 000000000000
-       2       141      68       2 bdd988058d16 cdca01651b96 000000000000
-       3       209      66       3 d8a521142a3c f6718a9cb7f3 bdd988058d16
+     rev linkrev nodeid       p1           p2
+       0       0 cdca01651b96 000000000000 000000000000
+       1       1 f6718a9cb7f3 cdca01651b96 000000000000
+       2       2 bdd988058d16 cdca01651b96 000000000000
+       3       3 d8a521142a3c f6718a9cb7f3 bdd988058d16
 
 log should show foo and quux changed:
 
   $ hg log -v -r tip
   changeset:   3:d8a521142a3c
   tag:         tip
   parent:      1:f6718a9cb7f3
   parent:      2:bdd988058d16
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo quux
   description:
   merge
   
   
 
 foo: we should have a merge here:
 
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       4       1 2ffeddde1b65 b8e02f643373 000000000000
-       2         7       4       2 33d1fb69067a b8e02f643373 000000000000
-       3        11       4       3 aa27919ee430 2ffeddde1b65 33d1fb69067a
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       1 2ffeddde1b65 b8e02f643373 000000000000
+       2       2 33d1fb69067a b8e02f643373 000000000000
+       3       3 aa27919ee430 2ffeddde1b65 33d1fb69067a
 
 bar: we should not have a merge here:
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       4       2 33d1fb69067a b8e02f643373 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       2 33d1fb69067a b8e02f643373 000000000000
 
 baz: we should not have a merge here:
 
   $ hg debugindex baz
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       4       1 2ffeddde1b65 b8e02f643373 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       1 2ffeddde1b65 b8e02f643373 000000000000
 
 quux: we should not have a merge here:
 
   $ hg debugindex quux
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       5       3 6128c0f33108 b8e02f643373 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       3 6128c0f33108 b8e02f643373 000000000000
 
 Manifest entries should match tips of all files:
 
   $ hg manifest --debug
   33d1fb69067a0139622a3fa3b7ba1cdb1367972e 644   bar
   2ffeddde1b65b4827f6746174a145474129fa2ce 644   baz
   aa27919ee4303cfd575e1fb932dd64d75aa08be4 644   foo
   6128c0f33108e8cfbb4e0824d13ae48b466d7280 644   quux
 
 Everything should be clean now:
 
   $ hg status
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 4 changesets, 10 total revisions
 
   $ cd ..

tests/test-flags.t

@@ -1,157 +1,157 b''
 #require execbit
 
   $ umask 027
 
   $ hg init test1
   $ cd test1
   $ touch a b
   $ hg add a b
   $ hg ci -m "added a b"
 
   $ cd ..
   $ hg clone test1 test3
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg init test2
   $ cd test2
   $ hg pull ../test1
   pulling from ../test1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   new changesets 22a449e20da5
   (run 'hg update' to get a working copy)
   $ hg co
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ chmod +x a
   $ hg ci -m "chmod +x a"
 
 the changelog should mention file a:
 
   $ hg tip --template '{files}\n'
   a
 
   $ cd ../test1
   $ echo 123 >>a
   $ hg ci -m "a updated"
 
   $ hg pull ../test2
   pulling from ../test2
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (+1 heads)
   new changesets 7f4313b42a34
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg heads
   changeset:   2:7f4313b42a34
   tag:         tip
   parent:      0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod +x a
   
   changeset:   1:c6ecefc45368
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a updated
   
   $ hg history
   changeset:   2:7f4313b42a34
   tag:         tip
   parent:      0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod +x a
   
   changeset:   1:c6ecefc45368
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a updated
   
   changeset:   0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added a b
   
 
   $ hg -v merge
   resolving manifests
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat a
   123
   $ [ -x a ]
 
   $ cd ../test3
   $ echo 123 >>b
   $ hg ci -m "b updated"
 
   $ hg pull ../test2
   pulling from ../test2
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (+1 heads)
   new changesets 7f4313b42a34
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg heads
   changeset:   2:7f4313b42a34
   tag:         tip
   parent:      0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod +x a
   
   changeset:   1:dc57ead75f79
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b updated
   
   $ hg history
   changeset:   2:7f4313b42a34
   tag:         tip
   parent:      0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     chmod +x a
   
   changeset:   1:dc57ead75f79
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b updated
   
   changeset:   0:22a449e20da5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     added a b
   
 
   $ hg -v merge
   resolving manifests
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ ls -l ../test[123]/a > foo
   $ cut -b 1-10 < foo
   -rwxr-x---
   -rwxr-x---
   -rwxr-x---
 
   $ hg debugindex a
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       0       0 b80de5d13875 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b80de5d13875 000000000000 000000000000
   $ hg debugindex -R ../test2 a
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       0       0 b80de5d13875 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b80de5d13875 000000000000 000000000000
   $ hg debugindex -R ../test1 a
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       0       0 b80de5d13875 000000000000 000000000000
-       1         0       5       1 7fe919cc0336 b80de5d13875 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b80de5d13875 000000000000 000000000000
+       1       1 7fe919cc0336 b80de5d13875 000000000000
 
   $ cd ..

tests/test-issue522.t

@@ -1,55 +1,55 b''
 https://bz.mercurial-scm.org/522
 
 In the merge below, the file "foo" has the same contents in both
 parents, but if we look at the file-level history, we'll notice that
 the version in p1 is an ancestor of the version in p2. This test makes
 sure that we'll use the version from p2 in the manifest of the merge
 revision.
 
   $ hg init
 
   $ echo foo > foo
   $ hg ci -qAm 'add foo'
 
   $ echo bar >> foo
   $ hg ci -m 'change foo'
 
   $ hg backout -r tip -m 'backout changed foo'
   reverting foo
   changeset 2:4d9e78aaceee backs out changeset 1:b515023e500e
 
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ touch bar
   $ hg ci -qAm 'add bar'
 
   $ hg merge --debug
     searching for copies back to rev 1
     unmatched files in local:
      bar
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: bbd179dfa0a7, local: 71766447bdbb+, remote: 4d9e78aaceee
    foo: remote is newer -> g
   getting foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg debugstate | grep foo
   m   0         -2 unset               foo
 
   $ hg st -A foo
   M foo
 
   $ hg ci -m 'merge'
 
   $ hg manifest --debug | grep foo
   c6fc755d7e68f49f880599da29f15add41f42f5a 644   foo
 
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       5       0 2ed2a3912a0b 000000000000 000000000000
-       1         5       9       1 6f4310b00b9a 2ed2a3912a0b 000000000000
-       2        14       5       2 c6fc755d7e68 6f4310b00b9a 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 2ed2a3912a0b 000000000000 000000000000
+       1       1 6f4310b00b9a 2ed2a3912a0b 000000000000
+       2       2 c6fc755d7e68 6f4310b00b9a 000000000000
 

tests/test-merge-commit.t

@@ -1,185 +1,185 b''
 Check that renames are correctly saved by a commit after a merge
 
 Test with the merge on 3 having the rename on the local parent
 
   $ hg init a
   $ cd a
 
   $ echo line1 > foo
   $ hg add foo
   $ hg ci -m '0: add foo'
 
   $ echo line2 >> foo
   $ hg ci -m '1: change foo'
 
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg mv foo bar
   $ rm bar
   $ echo line0 > bar
   $ echo line1 >> bar
   $ hg ci -m '2: mv foo bar; change bar'
   created new head
 
   $ hg merge 1
   merging bar and foo to bar
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat bar
   line0
   line1
   line2
 
   $ hg ci -m '3: merge with local rename'
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       2 d35118874825 000000000000 000000000000
-       1        77      76       3 5345f5ab8abd 000000000000 d35118874825
+     rev linkrev nodeid       p1           p2
+       0       2 d35118874825 000000000000 000000000000
+       1       3 5345f5ab8abd 000000000000 d35118874825
 
   $ hg debugrename bar
   bar renamed from foo:9e25c27b87571a1edee5ae4dddee5687746cc8e2
 
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       7       0 690b295714ae 000000000000 000000000000
-       1         7      13       1 9e25c27b8757 690b295714ae 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 690b295714ae 000000000000 000000000000
+       1       1 9e25c27b8757 690b295714ae 000000000000
 
 
 Revert the content change from rev 2:
 
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm bar
   $ echo line1 > bar
   $ hg ci -m '4: revert content change from rev 2'
   created new head
 
   $ hg log --template '{rev}:{node|short} {parents}\n'
   4:2263c1be0967 2:0f2ff26688b9 
   3:0555950ead28 2:0f2ff26688b9 1:5cd961e4045d 
   2:0f2ff26688b9 0:2665aaee66e9 
   1:5cd961e4045d 
   0:2665aaee66e9 
 
 This should use bar@rev2 as the ancestor:
 
   $ hg --debug merge 3
     searching for copies back to rev 1
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f2ff26688b9, local: 2263c1be0967+, remote: 0555950ead28
    preserving bar for resolve of bar
   starting 4 threads for background file closing (?)
    bar: versions differ -> m (premerge)
   picked tool ':merge' for bar (binary False symlink False changedelete False)
   merging bar
   my bar@2263c1be0967+ other bar@0555950ead28 ancestor bar@0f2ff26688b9
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat bar
   line1
   line2
 
   $ hg ci -m '5: merge'
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       2 d35118874825 000000000000 000000000000
-       1        77      76       3 5345f5ab8abd 000000000000 d35118874825
-       2       153       7       4 ff4b45017382 d35118874825 000000000000
-       3       160      13       5 3701b4893544 ff4b45017382 5345f5ab8abd
+     rev linkrev nodeid       p1           p2
+       0       2 d35118874825 000000000000 000000000000
+       1       3 5345f5ab8abd 000000000000 d35118874825
+       2       4 ff4b45017382 d35118874825 000000000000
+       3       5 3701b4893544 ff4b45017382 5345f5ab8abd
 
 
 Same thing, but with the merge on 3 having the rename
 on the remote parent:
 
   $ cd ..
   $ hg clone -U -r 1 -r 2 a b
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 2 files (+1 heads)
   new changesets 2665aaee66e9:0f2ff26688b9
   $ cd b
 
   $ hg up -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge 2
   merging foo and bar to bar
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat bar
   line0
   line1
   line2
 
   $ hg ci -m '3: merge with remote rename'
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       2 d35118874825 000000000000 000000000000
-       1        77      76       3 5345f5ab8abd 000000000000 d35118874825
+     rev linkrev nodeid       p1           p2
+       0       2 d35118874825 000000000000 000000000000
+       1       3 5345f5ab8abd 000000000000 d35118874825
 
   $ hg debugrename bar
   bar renamed from foo:9e25c27b87571a1edee5ae4dddee5687746cc8e2
 
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       7       0 690b295714ae 000000000000 000000000000
-       1         7      13       1 9e25c27b8757 690b295714ae 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 690b295714ae 000000000000 000000000000
+       1       1 9e25c27b8757 690b295714ae 000000000000
 
 
 Revert the content change from rev 2:
 
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm bar
   $ echo line1 > bar
   $ hg ci -m '4: revert content change from rev 2'
   created new head
 
   $ hg log --template '{rev}:{node|short} {parents}\n'
   4:2263c1be0967 2:0f2ff26688b9 
   3:3ffa6b9e35f0 1:5cd961e4045d 2:0f2ff26688b9 
   2:0f2ff26688b9 0:2665aaee66e9 
   1:5cd961e4045d 
   0:2665aaee66e9 
 
 This should use bar@rev2 as the ancestor:
 
   $ hg --debug merge 3
     searching for copies back to rev 1
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 0f2ff26688b9, local: 2263c1be0967+, remote: 3ffa6b9e35f0
    preserving bar for resolve of bar
   starting 4 threads for background file closing (?)
    bar: versions differ -> m (premerge)
   picked tool ':merge' for bar (binary False symlink False changedelete False)
   merging bar
   my bar@2263c1be0967+ other bar@3ffa6b9e35f0 ancestor bar@0f2ff26688b9
    premerge successful
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat bar
   line1
   line2
 
   $ hg ci -m '5: merge'
 
   $ hg debugindex bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       2 d35118874825 000000000000 000000000000
-       1        77      76       3 5345f5ab8abd 000000000000 d35118874825
-       2       153       7       4 ff4b45017382 d35118874825 000000000000
-       3       160      13       5 3701b4893544 ff4b45017382 5345f5ab8abd
+     rev linkrev nodeid       p1           p2
+       0       2 d35118874825 000000000000 000000000000
+       1       3 5345f5ab8abd 000000000000 d35118874825
+       2       4 ff4b45017382 d35118874825 000000000000
+       3       5 3701b4893544 ff4b45017382 5345f5ab8abd
 
   $ cd ..

tests/test-merge7.t

@@ -1,151 +1,151 b''
 initial
   $ hg init test-a
   $ cd test-a
   $ cat >test.txt <<"EOF"
   > 1
   > 2
   > 3
   > EOF
   $ hg add test.txt
   $ hg commit -m "Initial"
 
 clone
   $ cd ..
   $ hg clone test-a test-b
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 change test-a
   $ cd test-a
   $ cat >test.txt <<"EOF"
   > one
   > two
   > three
   > EOF
   $ hg commit -m "Numbers as words"
 
 change test-b
   $ cd ../test-b
   $ cat >test.txt <<"EOF"
   > 1
   > 2.5
   > 3
   > EOF
   $ hg commit -m "2 -> 2.5"
 
 now pull and merge from test-a
   $ hg pull ../test-a
   pulling from ../test-a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 96b70246a118
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg merge
   merging test.txt
   warning: conflicts while merging test.txt! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 resolve conflict
   $ cat >test.txt <<"EOF"
   > one
   > two-point-five
   > three
   > EOF
   $ rm -f *.orig
   $ hg resolve -m test.txt
   (no more unresolved files)
   $ hg commit -m "Merge 1"
 
 change test-a again
   $ cd ../test-a
   $ cat >test.txt <<"EOF"
   > one
   > two-point-one
   > three
   > EOF
   $ hg commit -m "two -> two-point-one"
 
 pull and merge from test-a again
   $ cd ../test-b
   $ hg pull ../test-a
   pulling from ../test-a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 40d11a4173a8
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg merge --debug
     searching for copies back to rev 1
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 96b70246a118, local: 50c3a7e29886+, remote: 40d11a4173a8
    preserving test.txt for resolve of test.txt
   starting 4 threads for background file closing (?)
    test.txt: versions differ -> m (premerge)
   picked tool ':merge' for test.txt (binary False symlink False changedelete False)
   merging test.txt
   my test.txt@50c3a7e29886+ other test.txt@40d11a4173a8 ancestor test.txt@96b70246a118
    test.txt: versions differ -> m (merge)
   picked tool ':merge' for test.txt (binary False symlink False changedelete False)
   my test.txt@50c3a7e29886+ other test.txt@40d11a4173a8 ancestor test.txt@96b70246a118
   warning: conflicts while merging test.txt! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ cat test.txt
   one
   <<<<<<< working copy: 50c3a7e29886 - test: Merge 1
   two-point-five
   =======
   two-point-one
   >>>>>>> merge rev:    40d11a4173a8 - test: two -> two-point-one
   three
 
   $ hg debugindex test.txt
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       7       0 01365c4cca56 000000000000 000000000000
-       1         7       9       1 7b013192566a 01365c4cca56 000000000000
-       2        16      15       2 8fe46a3eb557 01365c4cca56 000000000000
-       3        31      2.       3 fc3148072371 7b013192566a 8fe46a3eb557 (re)
-       4        5.      25       4 d40249267ae3 8fe46a3eb557 000000000000 (re)
+     rev linkrev nodeid       p1           p2
+       0       0 01365c4cca56 000000000000 000000000000
+       1       1 7b013192566a 01365c4cca56 000000000000
+       2       2 8fe46a3eb557 01365c4cca56 000000000000
+       3       3 fc3148072371 7b013192566a 8fe46a3eb557
+       4       4 d40249267ae3 8fe46a3eb557 000000000000
 
   $ hg log
   changeset:   4:40d11a4173a8
   tag:         tip
   parent:      2:96b70246a118
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     two -> two-point-one
   
   changeset:   3:50c3a7e29886
   parent:      1:d1e159716d41
   parent:      2:96b70246a118
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Merge 1
   
   changeset:   2:96b70246a118
   parent:      0:b1832b9d912a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Numbers as words
   
   changeset:   1:d1e159716d41
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2 -> 2.5
   
   changeset:   0:b1832b9d912a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Initial
   
 
   $ cd ..

tests/test-narrow-debugcommands.t

@@ -1,43 +1,43 b''
   $ . "$TESTDIR/narrow-library.sh"
   $ hg init repo
   $ cd repo
   $ cat << EOF > .hg/narrowspec
   > [includes]
   > path:foo
   > [excludes]
   > EOF
   $ echo treemanifest >> .hg/requires
   $ echo narrowhg-experimental >> .hg/requires
   $ mkdir -p foo/bar
   $ echo b > foo/f
   $ echo c > foo/bar/f
   $ hg commit -Am hi
   adding foo/bar/f
   adding foo/f
   $ hg debugindex -m
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      47       0 14a5d056d75a 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 14a5d056d75a 000000000000 000000000000
   $ hg debugindex --dir foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       0 e635c7857aef 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 e635c7857aef 000000000000 000000000000
   $ hg debugindex --dir foo/
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      77       0 e635c7857aef 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 e635c7857aef 000000000000 000000000000
   $ hg debugindex --dir foo/bar
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      44       0 e091d4224761 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 e091d4224761 000000000000 000000000000
   $ hg debugindex --dir foo/bar/
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      44       0 e091d4224761 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 e091d4224761 000000000000 000000000000
   $ hg debugdata -m 0
   foo\x00e635c7857aef92ac761ce5741a99da159abbbb24t (esc)
   $ hg debugdata --dir foo 0
   bar\x00e091d42247613adff5d41b67f15fe7189ee97b39t (esc)
   f\x001e88685f5ddec574a34c70af492f95b6debc8741 (esc)
   $ hg debugdata --dir foo/ 0
   bar\x00e091d42247613adff5d41b67f15fe7189ee97b39t (esc)
   f\x001e88685f5ddec574a34c70af492f95b6debc8741 (esc)
   $ hg debugdata --dir foo/bar 0
   f\x00149da44f2a4e14f488b7bd4157945a9837408c00 (esc)
   $ hg debugdata --dir foo/bar/ 0
   f\x00149da44f2a4e14f488b7bd4157945a9837408c00 (esc)

tests/test-narrow-update.t

@@ -1,76 +1,76 b''
 
   $ . "$TESTDIR/narrow-library.sh"
 
 create full repo
 
   $ hg init master
   $ cd master
   $ echo init > init
   $ hg ci -Aqm 'initial'
 
   $ mkdir inside
   $ echo inside > inside/f1
   $ mkdir outside
   $ echo outside > outside/f1
   $ hg ci -Aqm 'add inside and outside'
 
   $ echo modified > inside/f1
   $ hg ci -qm 'modify inside'
 
   $ echo modified > outside/f1
   $ hg ci -qm 'modify outside'
 
   $ cd ..
 
   $ hg clone --narrow ssh://user@dummy/master narrow --include inside
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 2 changes to 1 files
   new changesets *:* (glob)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd narrow
   $ hg debugindex -c
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      64       0 9958b1af2add 000000000000 000000000000
-       1        64      81       1 2db4ce2a3bfe 9958b1af2add 000000000000
-       2       145      75       2 0980ee31a742 2db4ce2a3bfe 000000000000
-       3       220      (76|77)       3 4410145019b7 0980ee31a742 000000000000 (re)
+     rev linkrev nodeid       p1           p2
+       0       0 9958b1af2add 000000000000 000000000000
+       1       1 2db4ce2a3bfe 9958b1af2add 000000000000
+       2       2 0980ee31a742 2db4ce2a3bfe 000000000000
+       3       3 4410145019b7 0980ee31a742 000000000000
 
   $ hg update -q 0
 
 Can update to revision with changes inside
 
   $ hg update -q 'desc("add inside and outside")'
   $ hg update -q 'desc("modify inside")'
   $ find *
   inside
   inside/f1
   $ cat inside/f1
   modified
 
 Can update to revision with changes outside
 
   $ hg update -q 'desc("modify outside")'
   $ find *
   inside
   inside/f1
   $ cat inside/f1
   modified
 
 Can update with a deleted file inside
 
   $ hg rm inside/f1
   $ hg update -q 'desc("modify inside")'
   $ hg update -q 'desc("modify outside")'
   $ hg update -q 'desc("initial")'
   $ hg update -q 'desc("modify inside")'
 
 Can update with a moved file inside
 
   $ hg mv inside/f1 inside/f2
   $ hg update -q 'desc("modify outside")'
   $ hg update -q 'desc("initial")'
   $ hg update -q 'desc("modify inside")'

tests/test-parseindex.t

@@ -1,203 +1,203 b''
 revlog.parseindex must be able to parse the index file even if
 an index entry is split between two 64k blocks.  The ideal test
 would be to create an index file with inline data where
 64k < size < 64k + 64 (64k is the size of the read buffer, 64 is
 the size of an index entry) and with an index entry starting right
 before the 64k block boundary, and try to read it.
 We approximate that by reducing the read buffer to 1 byte.
 
   $ hg init a
   $ cd a
   $ echo abc > foo
   $ hg add foo
   $ hg commit -m 'add foo'
   $ echo >> foo
   $ hg commit -m 'change foo'
   $ hg log -r 0:
   changeset:   0:7c31755bf9b5
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add foo
   
   changeset:   1:26333235a41c
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo
   
   $ cat >> test.py << EOF
   > from mercurial import changelog, vfs
   > from mercurial.node import *
   > 
   > class singlebyteread(object):
   >     def __init__(self, real):
   >         self.real = real
   > 
   >     def read(self, size=-1):
   >         if size == 65536:
   >             size = 1
   >         return self.real.read(size)
   > 
   >     def __getattr__(self, key):
   >         return getattr(self.real, key)
   > 
   >     def __enter__(self):
   >         self.real.__enter__()
   >         return self
   > 
   >     def __exit__(self, *args, **kwargs):
   >         return self.real.__exit__(*args, **kwargs)
   > 
   > def opener(*args):
   >     o = vfs.vfs(*args)
   >     def wrapper(*a, **kwargs):
   >         f = o(*a, **kwargs)
   >         return singlebyteread(f)
   >     return wrapper
   > 
   > cl = changelog.changelog(opener('.hg/store'))
   > print len(cl), 'revisions:'
   > for r in cl:
   >     print short(cl.node(r))
   > EOF
   $ $PYTHON test.py
   2 revisions:
   7c31755bf9b5
   26333235a41c
 
   $ cd ..
 
 #if no-pure
 
 Test SEGV caused by bad revision passed to reachableroots() (issue4775):
 
   $ cd a
 
   $ $PYTHON <<EOF
   > from mercurial import changelog, vfs
   > cl = changelog.changelog(vfs.vfs('.hg/store'))
   > print 'good heads:'
   > for head in [0, len(cl) - 1, -1]:
   >     print'%s: %r' % (head, cl.reachableroots(0, [head], [0]))
   > print 'bad heads:'
   > for head in [len(cl), 10000, -2, -10000, None]:
   >     print '%s:' % head,
   >     try:
   >         cl.reachableroots(0, [head], [0])
   >         print 'uncaught buffer overflow?'
   >     except (IndexError, TypeError) as inst:
   >         print inst
   > print 'good roots:'
   > for root in [0, len(cl) - 1, -1]:
   >     print '%s: %r' % (root, cl.reachableroots(root, [len(cl) - 1], [root]))
   > print 'out-of-range roots are ignored:'
   > for root in [len(cl), 10000, -2, -10000]:
   >     print '%s: %r' % (root, cl.reachableroots(root, [len(cl) - 1], [root]))
   > print 'bad roots:'
   > for root in [None]:
   >     print '%s:' % root,
   >     try:
   >         cl.reachableroots(root, [len(cl) - 1], [root])
   >         print 'uncaught error?'
   >     except TypeError as inst:
   >         print inst
   > EOF
   good heads:
   0: [0]
   1: [0]
   -1: []
   bad heads:
   2: head out of range
   10000: head out of range
   -2: head out of range
   -10000: head out of range
   None: an integer is required
   good roots:
   0: [0]
   1: [1]
   -1: [-1]
   out-of-range roots are ignored:
   2: []
   10000: []
   -2: []
   -10000: []
   bad roots:
   None: an integer is required
 
   $ cd ..
 
 Test corrupted p1/p2 fields that could cause SEGV at parsers.c:
 
   $ mkdir invalidparent
   $ cd invalidparent
 
   $ hg clone --pull -q --config phases.publish=False ../a limit
   $ hg clone --pull -q --config phases.publish=False ../a segv
   $ rm -R limit/.hg/cache segv/.hg/cache
 
   $ $PYTHON <<EOF
   > data = open("limit/.hg/store/00changelog.i", "rb").read()
   > for n, p in [('limit', '\0\0\0\x02'), ('segv', '\0\x01\0\0')]:
   >     # corrupt p1 at rev0 and p2 at rev1
   >     d = data[:24] + p + data[28:127 + 28] + p + data[127 + 32:]
   >     open(n + "/.hg/store/00changelog.i", "wb").write(d)
   > EOF
 
   $ hg -R limit debugindex -f1 -c
-     rev flag   offset   length     size   link     p1     p2       nodeid
-       0 0000        0       63       62      0      2     -1 7c31755bf9b5
-       1 0000       63       66       65      1      0      2 26333235a41c
+     rev flag     size   link     p1     p2       nodeid
+       0 0000       62      0      2     -1 7c31755bf9b5
+       1 0000       65      1      0      2 26333235a41c
 
   $ hg -R limit debugdeltachain -c
       rev  chain# chainlen     prev   delta       size    rawsize  chainsize     ratio   lindist extradist extraratio
         0       1        1       -1    base         63         62         63   1.01613        63         0    0.00000
         1       2        1       -1    base         66         65         66   1.01538        66         0    0.00000
 
   $ hg -R segv debugindex -f1 -c
-     rev flag   offset   length     size   link     p1     p2       nodeid
-       0 0000        0       63       62      0  65536     -1 7c31755bf9b5
-       1 0000       63       66       65      1      0  65536 26333235a41c
+     rev flag     size   link     p1     p2       nodeid
+       0 0000       62      0  65536     -1 7c31755bf9b5
+       1 0000       65      1      0  65536 26333235a41c
 
   $ hg -R segv debugdeltachain -c
       rev  chain# chainlen     prev   delta       size    rawsize  chainsize     ratio   lindist extradist extraratio
         0       1        1       -1    base         63         62         63   1.01613        63         0    0.00000
         1       2        1       -1    base         66         65         66   1.01538        66         0    0.00000
 
   $ cat <<EOF > test.py
   > import sys
   > from mercurial import changelog, vfs
   > cl = changelog.changelog(vfs.vfs(sys.argv[1]))
   > n0, n1 = cl.node(0), cl.node(1)
   > ops = [
   >     ('reachableroots',
   >      lambda: cl.index.reachableroots2(0, [1], [0], False)),
   >     ('compute_phases_map_sets', lambda: cl.computephases([[0], []])),
   >     ('index_headrevs', lambda: cl.headrevs()),
   >     ('find_gca_candidates', lambda: cl.commonancestorsheads(n0, n1)),
   >     ('find_deepest', lambda: cl.ancestor(n0, n1)),
   >     ]
   > for l, f in ops:
   >     print l + ':',
   >     try:
   >         f()
   >         print 'uncaught buffer overflow?'
   >     except ValueError, inst:
   >         print inst
   > EOF
 
   $ $PYTHON test.py limit/.hg/store
   reachableroots: parent out of range
   compute_phases_map_sets: parent out of range
   index_headrevs: parent out of range
   find_gca_candidates: parent out of range
   find_deepest: parent out of range
   $ $PYTHON test.py segv/.hg/store
   reachableroots: parent out of range
   compute_phases_map_sets: parent out of range
   index_headrevs: parent out of range
   find_gca_candidates: parent out of range
   find_deepest: parent out of range
 
   $ cd ..
 
 #endif

tests/test-rename-merge1.t

@@ -1,188 +1,188 b''
   $ hg init
 
   $ echo "[merge]" >> .hg/hgrc
   $ echo "followcopies = 1" >> .hg/hgrc
 
   $ echo foo > a
   $ echo foo > a2
   $ hg add a a2
   $ hg ci -m "start"
 
   $ hg mv a b
   $ hg mv a2 b2
   $ hg ci -m "rename"
 
   $ hg co 0
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
   $ echo blahblah > a
   $ echo blahblah > a2
   $ hg mv a2 c2
   $ hg ci -m "modify"
   created new head
 
   $ hg merge -y --debug
     searching for copies back to rev 1
     unmatched files in local:
      c2
     unmatched files in other:
      b
      b2
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'a' -> dst: 'b' *
      src: 'a2' -> dst: 'b2' !
      src: 'a2' -> dst: 'c2' !
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: af1939970a1c, local: 044f8520aeeb+, remote: 85c198ef2f6c
   note: possible conflict - a2 was renamed multiple times to:
    c2
    b2
    preserving a for resolve of b
   removing a
    b2: remote created -> g
   getting b2
    b: remote moved from a -> m (premerge)
   picked tool ':merge' for b (binary False symlink False changedelete False)
   merging a and b to b
   my b@044f8520aeeb+ other b@85c198ef2f6c ancestor a@af1939970a1c
    premerge successful
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg status -AC
   M b
     a
   M b2
   R a
   C c2
 
   $ cat b
   blahblah
 
   $ hg ci -m "merge"
 
   $ hg debugindex b
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      67       1 57eacc201a7f 000000000000 000000000000
-       1        67      72       3 4727ba907962 000000000000 57eacc201a7f
+     rev linkrev nodeid       p1           p2
+       0       1 57eacc201a7f 000000000000 000000000000
+       1       3 4727ba907962 000000000000 57eacc201a7f
 
   $ hg debugrename b
   b renamed from a:dd03b83622e78778b403775d0d074b9ac7387a66
 
 This used to trigger a "divergent renames" warning, despite no renames
 
   $ hg cp b b3
   $ hg cp b b4
   $ hg ci -A -m 'copy b twice'
   $ hg up eb92d88a9712
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg rm b3 b4
   $ hg ci -m 'clean up a bit of our mess'
 
 We'd rather not warn on divergent renames done in the same changeset (issue2113)
 
   $ hg cp b b3
   $ hg mv b b4
   $ hg ci -A -m 'divergent renames in same changeset'
   $ hg up c761c6948de0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Check for issue2642
 
   $ hg init t
   $ cd t
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1 # backport
   $ hg ci -Aqm1
   $ hg mv f1 f2
   $ hg ci -qm2
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ hg ci -qm3
 
   $ hg merge 2
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c0
 
   $ cd ..
 
 Check for issue2089
 
   $ hg init repo2089
   $ cd repo2089
 
   $ echo c0 > f1
   $ hg ci -Aqm0
 
   $ hg up null -q
   $ echo c1 > f1
   $ hg ci -Aqm1
 
   $ hg up 0 -q
   $ hg merge 1 -q --tool internal:local
   $ echo c2 > f1
   $ hg ci -qm2
 
   $ hg up 1 -q
   $ hg mv f1 f2
   $ hg ci -Aqm3
 
   $ hg up 2 -q
   $ hg merge 3
   merging f1 and f2 to f2
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ cat f2
   c2
 
   $ cd ..
 
 Check for issue3074
 
   $ hg init repo3074
   $ cd repo3074
   $ echo foo > file
   $ hg add file
   $ hg commit -m "added file"
   $ hg mv file newfile
   $ hg commit -m "renamed file"
   $ hg update 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg rm file
   $ hg commit -m "deleted file"
   created new head
   $ hg merge --debug
     searching for copies back to rev 1
     unmatched files in other:
      newfile
     all copies found (* = to merge, ! = divergent, % = renamed and deleted):
      src: 'file' -> dst: 'newfile' %
     checking for directory renames
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: 19d7f95df299, local: 0084274f6b67+, remote: 5d32493049f0
   note: possible conflict - file was deleted and renamed to:
    newfile
    newfile: remote created -> g
   getting newfile
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg status
   M newfile
   $ cd ..

tests/test-revlog-packentry.t

@@ -1,23 +1,23 b''
   $ hg init repo
   $ cd repo
 
   $ touch foo
   $ hg ci -Am 'add foo'
   adding foo
 
   $ hg up -C null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 this should be stored as a delta against rev 0
 
   $ echo foo bar baz > foo
   $ hg ci -Am 'add foo again'
   adding foo
   created new head
 
   $ hg debugindex foo
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       0       0 b80de5d13875 000000000000 000000000000
-       1         0      13       1 0376abec49b8 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b80de5d13875 000000000000 000000000000
+       1       1 0376abec49b8 000000000000 000000000000
 
   $ cd ..

tests/test-revlog.t

@@ -1,47 +1,47 b''
   $ hg init empty-repo
   $ cd empty-repo
 
 Flags on revlog version 0 are rejected
 
   >>> with open('.hg/store/00changelog.i', 'wb') as fh:
   ...     fh.write(b'\x00\x01\x00\x00')
 
   $ hg log
   abort: unknown flags (0x01) in version 0 revlog 00changelog.i!
   [255]
 
 Unknown flags on revlog version 1 are rejected
 
   >>> with open('.hg/store/00changelog.i', 'wb') as fh:
   ...     fh.write(b'\x00\x04\x00\x01')
 
   $ hg log
   abort: unknown flags (0x04) in version 1 revlog 00changelog.i!
   [255]
 
 Unknown version is rejected
 
   >>> with open('.hg/store/00changelog.i', 'wb') as fh:
   ...     fh.write(b'\x00\x00\x00\x02')
 
   $ hg log
   abort: unknown version (2) in revlog 00changelog.i!
   [255]
 
   $ cd ..
 
 Test for CVE-2016-3630
 
   $ hg init
 
   >>> open("a.i", "wb").write(
   ... b"""eJxjYGZgZIAAYQYGxhgom+k/FMx8YKx9ZUaKSOyqo4cnuKb8mbqHV5cBCVTMWb1Cwqkhe4Gsg9AD
   ... Joa3dYtcYYYBAQ8Qr4OqZAYRICPTSr5WKd/42rV36d+8/VmrNpv7NP1jQAXrQE4BqQUARngwVA=="""
   ... .decode("base64").decode("zlib"))
 
   $ hg debugindex a.i
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      19       2 99e0332bd498 000000000000 000000000000
-       1        19      12       3 6674f57a23d8 99e0332bd498 000000000000
+     rev linkrev nodeid       p1           p2
+       0       2 99e0332bd498 000000000000 000000000000
+       1       3 6674f57a23d8 99e0332bd498 000000000000
   $ hg debugdata a.i 1 2>&1 | egrep 'Error:.*decoded'
   (mercurial\.\w+\.mpatch\.)?mpatchError: patch cannot be decoded (re)

tests/test-strip-cross.t

@@ -1,143 +1,143 b''
 test stripping of filelogs where the linkrev doesn't always increase
 
   $ echo '[extensions]' >> $HGRCPATH
   $ echo 'strip =' >> $HGRCPATH
   $ hg init orig
   $ cd orig
   $ commit()
   > {
   >     hg up -qC null
   >     count=1
   >     for i in "$@"; do
   >         for f in $i; do
   >             echo $count > $f
   >         done
   >         count=`expr $count + 1`
   >     done
   >     hg commit -qAm "$*"
   > }
 
 2 1 0 2 0 1 2
 
   $ commit '201 210'
   $ commit '102 120' '210'
   $ commit '021'
   $ commit '201' '021 120'
   $ commit '012 021' '102 201' '120 210'
   $ commit 'manifest-file'
   $ commit '102 120' '012 210' '021 201'
   $ commit '201 210' '021 120' '012 102'
   $ HGUSER=another-user; export HGUSER
   $ commit 'manifest-file'
   $ commit '012' 'manifest-file'
   $ cd ..
   $ hg clone -q -U -r -1 -r -2 -r -3 -r -4 -r -6 orig crossed
   $ cd crossed
   $ hg debugindex --manifest
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0     112       0 6f105cbb914d 000000000000 000000000000
-       1       112      56       3 1b55917b3699 000000000000 000000000000
-       2       168     123       1 8f3d04e263e5 000000000000 000000000000
-       3       291     122       2 f0ef8726ac4f 000000000000 000000000000
-       4       413      87       4 0b76e38b4070 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 6f105cbb914d 000000000000 000000000000
+       1       3 1b55917b3699 000000000000 000000000000
+       2       1 8f3d04e263e5 000000000000 000000000000
+       3       2 f0ef8726ac4f 000000000000 000000000000
+       4       4 0b76e38b4070 000000000000 000000000000
 
   $ for i in 012 021 102 120 201 210 manifest-file; do
   >     echo $i
   >     hg debugindex $i
   >     echo
   > done
   012
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       3       1 5d9299349fc0 000000000000 000000000000
-       2         6       3       2 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       1 5d9299349fc0 000000000000 000000000000
+       2       2 2661d26c6496 000000000000 000000000000
   
   021
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       0 b8e02f643373 000000000000 000000000000
-       1         3       3       2 5d9299349fc0 000000000000 000000000000
-       2         6       3       1 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       0 b8e02f643373 000000000000 000000000000
+       1       2 5d9299349fc0 000000000000 000000000000
+       2       1 2661d26c6496 000000000000 000000000000
   
   102
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       1 b8e02f643373 000000000000 000000000000
-       1         3       3       0 5d9299349fc0 000000000000 000000000000
-       2         6       3       2 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       1 b8e02f643373 000000000000 000000000000
+       1       0 5d9299349fc0 000000000000 000000000000
+       2       2 2661d26c6496 000000000000 000000000000
   
   120
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       1 b8e02f643373 000000000000 000000000000
-       1         3       3       2 5d9299349fc0 000000000000 000000000000
-       2         6       3       0 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       1 b8e02f643373 000000000000 000000000000
+       1       2 5d9299349fc0 000000000000 000000000000
+       2       0 2661d26c6496 000000000000 000000000000
   
   201
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       2 b8e02f643373 000000000000 000000000000
-       1         3       3       0 5d9299349fc0 000000000000 000000000000
-       2         6       3       1 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       2 b8e02f643373 000000000000 000000000000
+       1       0 5d9299349fc0 000000000000 000000000000
+       2       1 2661d26c6496 000000000000 000000000000
   
   210
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       2 b8e02f643373 000000000000 000000000000
-       1         3       3       1 5d9299349fc0 000000000000 000000000000
-       2         6       3       0 2661d26c6496 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       2 b8e02f643373 000000000000 000000000000
+       1       1 5d9299349fc0 000000000000 000000000000
+       2       0 2661d26c6496 000000000000 000000000000
   
   manifest-file
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0       3       3 b8e02f643373 000000000000 000000000000
-       1         3       3       4 5d9299349fc0 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       3 b8e02f643373 000000000000 000000000000
+       1       4 5d9299349fc0 000000000000 000000000000
   
   $ cd ..
   $ for i in 0 1 2 3 4; do
   >     hg clone -q -U --pull crossed $i
   >     echo "% Trying to strip revision $i"
   >     hg --cwd $i strip $i
   >     echo "% Verifying"
   >     hg --cwd $i verify
   >     echo
   > done
   % Trying to strip revision 0
   saved backup bundle to $TESTTMP/0/.hg/strip-backup/*-backup.hg (glob)
   % Verifying
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   7 files, 4 changesets, 15 total revisions
   
   % Trying to strip revision 1
   saved backup bundle to $TESTTMP/1/.hg/strip-backup/*-backup.hg (glob)
   % Verifying
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   7 files, 4 changesets, 14 total revisions
   
   % Trying to strip revision 2
   saved backup bundle to $TESTTMP/2/.hg/strip-backup/*-backup.hg (glob)
   % Verifying
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   7 files, 4 changesets, 14 total revisions
   
   % Trying to strip revision 3
   saved backup bundle to $TESTTMP/3/.hg/strip-backup/*-backup.hg (glob)
   % Verifying
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   7 files, 4 changesets, 19 total revisions
   
   % Trying to strip revision 4
   saved backup bundle to $TESTTMP/4/.hg/strip-backup/*-backup.hg (glob)
   % Verifying
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   7 files, 4 changesets, 19 total revisions
   

tests/test-treemanifest.t

@@ -1,876 +1,876 b''
 #require killdaemons
 
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usegeneraldelta=yes
   > [ui]
   > ssh=$PYTHON "$TESTDIR/dummyssh"
   > EOF
 
 Set up repo
 
   $ hg --config experimental.treemanifest=True init repo
   $ cd repo
 
 Requirements get set on init
 
   $ grep treemanifest .hg/requires
   treemanifest
 
 Without directories, looks like any other repo
 
   $ echo 0 > a
   $ echo 0 > b
   $ hg ci -Aqm initial
   $ hg debugdata -m 0
   a\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   b\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
 
 Submanifest is stored in separate revlog
 
   $ mkdir dir1
   $ echo 1 > dir1/a
   $ echo 1 > dir1/b
   $ echo 1 > e
   $ hg ci -Aqm 'add dir1'
   $ hg debugdata -m 1
   a\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   b\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   dir1\x008b3ffd73f901e83304c83d33132c8e774ceac44et (esc)
   e\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   $ hg debugdata --dir dir1 0
   a\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   b\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
 
 Can add nested directories
 
   $ mkdir dir1/dir1
   $ echo 2 > dir1/dir1/a
   $ echo 2 > dir1/dir1/b
   $ mkdir dir1/dir2
   $ echo 2 > dir1/dir2/a
   $ echo 2 > dir1/dir2/b
   $ hg ci -Aqm 'add dir1/dir1'
   $ hg files -r .
   a
   b
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
   e
 
 The manifest command works
 
   $ hg manifest
   a
   b
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
   e
 
 Revision is not created for unchanged directory
 
   $ mkdir dir2
   $ echo 3 > dir2/a
   $ hg add dir2
   adding dir2/a
   $ hg debugindex --dir dir1 > before
   $ hg ci -qm 'add dir2'
   $ hg debugindex --dir dir1 > after
   $ diff before after
   $ rm before after
 
 Removing directory does not create an revlog entry
 
   $ hg rm dir1/dir1
   removing dir1/dir1/a
   removing dir1/dir1/b
   $ hg debugindex --dir dir1/dir1 > before
   $ hg ci -qm 'remove dir1/dir1'
   $ hg debugindex --dir dir1/dir1 > after
   $ diff before after
   $ rm before after
 
 Check that hg files (calls treemanifest.walk()) works
 without loading all directory revlogs
 
   $ hg co 'desc("add dir2")'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mv .hg/store/meta/dir2 .hg/store/meta/dir2-backup
   $ hg files -r . dir1
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
 
 Check that status between revisions works (calls treemanifest.matches())
 without loading all directory revlogs
 
   $ hg status --rev 'desc("add dir1")' --rev . dir1
   A dir1/dir1/a
   A dir1/dir1/b
   A dir1/dir2/a
   A dir1/dir2/b
   $ mv .hg/store/meta/dir2-backup .hg/store/meta/dir2
 
 Merge creates 2-parent revision of directory revlog
 
   $ echo 5 > dir1/a
   $ hg ci -Aqm 'modify dir1/a'
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 6 > dir1/b
   $ hg ci -Aqm 'modify dir1/b'
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'conflict-free merge involving dir1/'
   $ cat dir1/a
   5
   $ cat dir1/b
   6
   $ hg debugindex --dir dir1
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      54       1 8b3ffd73f901 000000000000 000000000000
-       1        54      68       2 68e9d057c5a8 8b3ffd73f901 000000000000
-       2       122      12       4 4698198d2624 68e9d057c5a8 000000000000
-       3       134      55       5 44844058ccce 68e9d057c5a8 000000000000
-       4       189      55       6 bf3d9b744927 68e9d057c5a8 000000000000
-       5       244      55       7 dde7c0af2a03 bf3d9b744927 44844058ccce
+     rev linkrev nodeid       p1           p2
+       0       1 8b3ffd73f901 000000000000 000000000000
+       1       2 68e9d057c5a8 8b3ffd73f901 000000000000
+       2       4 4698198d2624 68e9d057c5a8 000000000000
+       3       5 44844058ccce 68e9d057c5a8 000000000000
+       4       6 bf3d9b744927 68e9d057c5a8 000000000000
+       5       7 dde7c0af2a03 bf3d9b744927 44844058ccce
 
 Merge keeping directory from parent 1 does not create revlog entry. (Note that
 dir1's manifest does change, but only because dir1/a's filelog changes.)
 
   $ hg co 'desc("add dir2")'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 8 > dir2/a
   $ hg ci -m 'modify dir2/a'
   created new head
 
   $ hg debugindex --dir dir2 > before
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg revert -r 'desc("modify dir2/a")' .
   reverting dir1/a
   $ hg ci -m 'merge, keeping parent 1'
   $ hg debugindex --dir dir2 > after
   $ diff before after
   $ rm before after
 
 Merge keeping directory from parent 2 does not create revlog entry. (Note that
 dir2's manifest does change, but only because dir2/a's filelog changes.)
 
   $ hg co 'desc("modify dir2/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugindex --dir dir1 > before
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg revert -r 'desc("modify dir1/a")' .
   reverting dir2/a
   $ hg ci -m 'merge, keeping parent 2'
   created new head
   $ hg debugindex --dir dir1 > after
   $ diff before after
   $ rm before after
 
 Create flat source repo for tests with mixed flat/tree manifests
 
   $ cd ..
   $ hg init repo-flat
   $ cd repo-flat
 
 Create a few commits with flat manifest
 
   $ echo 0 > a
   $ echo 0 > b
   $ echo 0 > e
   $ for d in dir1 dir1/dir1 dir1/dir2 dir2
   > do
   >   mkdir $d
   >   echo 0 > $d/a
   >   echo 0 > $d/b
   > done
   $ hg ci -Aqm initial
 
   $ echo 1 > a
   $ echo 1 > dir1/a
   $ echo 1 > dir1/dir1/a
   $ hg ci -Aqm 'modify on branch 1'
 
   $ hg co 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > b
   $ echo 2 > dir1/b
   $ echo 2 > dir1/dir1/b
   $ hg ci -Aqm 'modify on branch 2'
 
   $ hg merge 1
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge of flat manifests to new flat manifest'
 
   $ hg serve -p $HGPORT -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 Create clone with tree manifests enabled
 
   $ cd ..
   $ hg clone --config experimental.treemanifest=1 \
   >   http://localhost:$HGPORT repo-mixed -r 1
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 14 changes to 11 files
   new changesets 5b02a3e8db7e:581ef6037d8b
   updating to branch default
   11 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo-mixed
   $ test -d .hg/store/meta
   [1]
   $ grep treemanifest .hg/requires
   treemanifest
 
 Should be possible to push updates from flat to tree manifest repo
 
   $ hg -R ../repo-flat push ssh://user@dummy/repo-mixed
   pushing to ssh://user@dummy/repo-mixed
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 2 changesets with 3 changes to 3 files
 
 Commit should store revlog per directory
 
   $ hg co 1
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 > a
   $ echo 3 > dir1/a
   $ echo 3 > dir1/dir1/a
   $ hg ci -m 'first tree'
   created new head
   $ find .hg/store/meta | sort
   .hg/store/meta
   .hg/store/meta/dir1
   .hg/store/meta/dir1/00manifest.i
   .hg/store/meta/dir1/dir1
   .hg/store/meta/dir1/dir1/00manifest.i
   .hg/store/meta/dir1/dir2
   .hg/store/meta/dir1/dir2/00manifest.i
   .hg/store/meta/dir2
   .hg/store/meta/dir2/00manifest.i
 
 Merge of two trees
 
   $ hg co 2
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 1
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge of flat manifests to new tree manifest'
   created new head
   $ hg diff -r 3
 
 Parent of tree root manifest should be flat manifest, and two for merge
 
   $ hg debugindex -m
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0      80       0 40536115ed9e 000000000000 000000000000
-       1        80      83       1 f3376063c255 40536115ed9e 000000000000
-       2       163      89       2 5d9b9da231a2 40536115ed9e 000000000000
-       3       252      83       3 d17d663cbd8a 5d9b9da231a2 f3376063c255
-       4       335     124       4 51e32a8c60ee f3376063c255 000000000000
-       5       459     126       5 cc5baa78b230 5d9b9da231a2 f3376063c255
+     rev linkrev nodeid       p1           p2
+       0       0 40536115ed9e 000000000000 000000000000
+       1       1 f3376063c255 40536115ed9e 000000000000
+       2       2 5d9b9da231a2 40536115ed9e 000000000000
+       3       3 d17d663cbd8a 5d9b9da231a2 f3376063c255
+       4       4 51e32a8c60ee f3376063c255 000000000000
+       5       5 cc5baa78b230 5d9b9da231a2 f3376063c255
 
 
 Status across flat/tree boundary should work
 
   $ hg status --rev '.^' --rev .
   M a
   M dir1/a
   M dir1/dir1/a
 
 
 Turning off treemanifest config has no effect
 
   $ hg debugindex --dir dir1
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0     127       4 064927a0648a 000000000000 000000000000
-       1       127     111       5 25ecb8cb8618 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       4 064927a0648a 000000000000 000000000000
+       1       5 25ecb8cb8618 000000000000 000000000000
   $ echo 2 > dir1/a
   $ hg --config experimental.treemanifest=False ci -qm 'modify dir1/a'
   $ hg debugindex --dir dir1
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0     127       4 064927a0648a 000000000000 000000000000
-       1       127     111       5 25ecb8cb8618 000000000000 000000000000
-       2       238      55       6 5b16163a30c6 25ecb8cb8618 000000000000
+     rev linkrev nodeid       p1           p2
+       0       4 064927a0648a 000000000000 000000000000
+       1       5 25ecb8cb8618 000000000000 000000000000
+       2       6 5b16163a30c6 25ecb8cb8618 000000000000
 
 Stripping and recovering changes should work
 
   $ hg st --change tip
   M dir1/a
   $ hg --config extensions.strip= strip tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/repo-mixed/.hg/strip-backup/51cfd7b1e13b-78a2f3ed-backup.hg
   $ hg debugindex --dir dir1
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0     127       4 064927a0648a 000000000000 000000000000
-       1       127     111       5 25ecb8cb8618 000000000000 000000000000
+     rev linkrev nodeid       p1           p2
+       0       4 064927a0648a 000000000000 000000000000
+       1       5 25ecb8cb8618 000000000000 000000000000
   $ hg incoming .hg/strip-backup/*
   comparing with .hg/strip-backup/*-backup.hg (glob)
   searching for changes
   changeset:   6:51cfd7b1e13b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify dir1/a
   
   $ hg pull .hg/strip-backup/*
   pulling from .hg/strip-backup/51cfd7b1e13b-78a2f3ed-backup.hg
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 51cfd7b1e13b
   (run 'hg update' to get a working copy)
   $ hg --config extensions.strip= strip tip
   saved backup bundle to $TESTTMP/repo-mixed/.hg/strip-backup/*-backup.hg (glob)
   $ hg unbundle -q .hg/strip-backup/*
   $ hg debugindex --dir dir1
-     rev    offset  length linkrev nodeid       p1           p2
-       0         0     127       4 064927a0648a 000000000000 000000000000
-       1       127     111       5 25ecb8cb8618 000000000000 000000000000
-       2       238      55       6 5b16163a30c6 25ecb8cb8618 000000000000
+     rev linkrev nodeid       p1           p2
+       0       4 064927a0648a 000000000000 000000000000
+       1       5 25ecb8cb8618 000000000000 000000000000
+       2       6 5b16163a30c6 25ecb8cb8618 000000000000
   $ hg st --change tip
   M dir1/a
 
 Shelving and unshelving should work
 
   $ echo foo >> dir1/a
   $ hg --config extensions.shelve= shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --config extensions.shelve= unshelve
   unshelving change 'default'
   $ hg diff --nodates
   diff -r 708a273da119 dir1/a
   --- a/dir1/a
   +++ b/dir1/a
   @@ -1,1 +1,2 @@
    1
   +foo
 
 Pushing from treemanifest repo to an empty repo makes that a treemanifest repo
 
   $ cd ..
   $ hg init empty-repo
   $ cat << EOF >> empty-repo/.hg/hgrc
   > [experimental]
   > changegroup3=yes
   > EOF
   $ grep treemanifest empty-repo/.hg/requires
   [1]
   $ hg push -R repo -r 0 empty-repo
   pushing to empty-repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   $ grep treemanifest empty-repo/.hg/requires
   treemanifest
 
 Pushing to an empty repo works
 
   $ hg --config experimental.treemanifest=1 init clone
   $ grep treemanifest clone/.hg/requires
   treemanifest
   $ hg push -R repo clone
   pushing to clone
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 15 changes to 10 files (+3 heads)
   $ grep treemanifest clone/.hg/requires
   treemanifest
   $ hg -R clone verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 11 changesets, 15 total revisions
 
 Create deeper repo with tree manifests.
 
   $ hg --config experimental.treemanifest=True init deeprepo
   $ cd deeprepo
 
   $ mkdir .A
   $ mkdir b
   $ mkdir b/bar
   $ mkdir b/bar/orange
   $ mkdir b/bar/orange/fly
   $ mkdir b/foo
   $ mkdir b/foo/apple
   $ mkdir b/foo/apple/bees
 
   $ touch .A/one.txt
   $ touch .A/two.txt
   $ touch b/bar/fruits.txt
   $ touch b/bar/orange/fly/gnat.py
   $ touch b/bar/orange/fly/housefly.txt
   $ touch b/foo/apple/bees/flower.py
   $ touch c.txt
   $ touch d.py
 
   $ hg ci -Aqm 'initial'
 
   $ echo >> .A/one.txt
   $ echo >> .A/two.txt
   $ echo >> b/bar/fruits.txt
   $ echo >> b/bar/orange/fly/gnat.py
   $ echo >> b/bar/orange/fly/housefly.txt
   $ echo >> b/foo/apple/bees/flower.py
   $ echo >> c.txt
   $ echo >> d.py
   $ hg ci -Aqm 'second'
 
 We'll see that visitdir works by removing some treemanifest revlogs and running
 the files command with various parameters.
 
 Test files from the root.
 
   $ hg files -r .
   .A/one.txt
   .A/two.txt
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   b/foo/apple/bees/flower.py
   c.txt
   d.py
 
 Excludes with a glob should not exclude everything from the glob's root
 
   $ hg files -r . -X 'b/fo?' b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ cp -R .hg/store .hg/store-copy
 
 Test files for a subdirectory.
 
   $ rm -r .hg/store/meta/~2e_a
   $ hg files -r . b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   b/foo/apple/bees/flower.py
   $ hg diff -r '.^' -r . --stat b
    b/bar/fruits.txt              |  1 +
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    b/foo/apple/bees/flower.py    |  1 +
    4 files changed, 4 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files with just includes and excludes.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/bar/orange/fly
   $ rm -r .hg/store/meta/b/foo/apple/bees
   $ hg files -r . -I path:b/bar -X path:b/bar/orange/fly -I path:b/foo -X path:b/foo/apple/bees
   b/bar/fruits.txt
   $ hg diff -r '.^' -r . --stat -I path:b/bar -X path:b/bar/orange/fly -I path:b/foo -X path:b/foo/apple/bees
    b/bar/fruits.txt |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a subdirectory, excluding a directory within it.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ hg files -r . -X path:b/foo b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ hg diff -r '.^' -r . --stat -X path:b/foo b
    b/bar/fruits.txt              |  1 +
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    3 files changed, 3 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a sub directory, including only a directory within it, and
 including an unrelated directory.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ hg files -r . -I path:b/bar/orange -I path:a b
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ hg diff -r '.^' -r . --stat -I path:b/bar/orange -I path:a b
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    2 files changed, 2 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a pattern, including a directory, and excluding a directory
 within that.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ rm -r .hg/store/meta/b/bar/orange
   $ hg files -r . glob:**.txt -I path:b/bar -X path:b/bar/orange
   b/bar/fruits.txt
   $ hg diff -r '.^' -r . --stat glob:**.txt -I path:b/bar -X path:b/bar/orange
    b/bar/fruits.txt |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Add some more changes to the deep repo
   $ echo narf >> b/bar/fruits.txt
   $ hg ci -m narf
   $ echo troz >> b/bar/orange/fly/gnat.py
   $ hg ci -m troz
 
 Verify works
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Dirlogs are included in fncache
   $ grep meta/.A/00manifest.i .hg/store/fncache
   meta/.A/00manifest.i
 
 Rebuilt fncache includes dirlogs
   $ rm .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.A/one.txt.i
   adding data/.A/two.txt.i
   adding data/b/bar/fruits.txt.i
   adding data/b/bar/orange/fly/gnat.py.i
   adding data/b/bar/orange/fly/housefly.txt.i
   adding data/b/foo/apple/bees/flower.py.i
   adding data/c.txt.i
   adding data/d.py.i
   adding meta/.A/00manifest.i
   adding meta/b/00manifest.i
   adding meta/b/bar/00manifest.i
   adding meta/b/bar/orange/00manifest.i
   adding meta/b/bar/orange/fly/00manifest.i
   adding meta/b/foo/00manifest.i
   adding meta/b/foo/apple/00manifest.i
   adding meta/b/foo/apple/bees/00manifest.i
   16 items added, 0 removed from fncache
 
 Finish first server
   $ killdaemons.py
 
 Back up the recently added revlogs
   $ cp -R .hg/store .hg/store-newcopy
 
 Verify reports missing dirlog
   $ rm .hg/store/meta/b/00manifest.*
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
    0: empty or missing b/
    b/@0: parent-directory manifest refers to unknown revision 67688a370455
    b/@1: parent-directory manifest refers to unknown revision f065da70369e
    b/@2: parent-directory manifest refers to unknown revision ac0d30948e0b
    b/@3: parent-directory manifest refers to unknown revision 367152e6af28
   warning: orphan revlog 'meta/b/bar/00manifest.i'
   warning: orphan revlog 'meta/b/bar/orange/00manifest.i'
   warning: orphan revlog 'meta/b/bar/orange/fly/00manifest.i'
   warning: orphan revlog 'meta/b/foo/00manifest.i'
   warning: orphan revlog 'meta/b/foo/apple/00manifest.i'
   warning: orphan revlog 'meta/b/foo/apple/bees/00manifest.i'
   crosschecking files in changesets and manifests
    b/bar/fruits.txt@0: in changeset but not in manifest
    b/bar/orange/fly/gnat.py@0: in changeset but not in manifest
    b/bar/orange/fly/housefly.txt@0: in changeset but not in manifest
    b/foo/apple/bees/flower.py@0: in changeset but not in manifest
   checking files
   8 files, 4 changesets, 18 total revisions
   6 warnings encountered!
   9 integrity errors encountered!
   (first damaged changeset appears to be 0)
   [1]
   $ cp -R .hg/store-newcopy/. .hg/store
 
 Verify reports missing dirlog entry
   $ mv -f .hg/store-copy/meta/b/00manifest.* .hg/store/meta/b/
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
    b/@2: parent-directory manifest refers to unknown revision ac0d30948e0b
    b/@3: parent-directory manifest refers to unknown revision 367152e6af28
    b/bar/@?: rev 2 points to unexpected changeset 2
    b/bar/@?: 44d7e1146e0d not in parent-directory manifest
    b/bar/@?: rev 3 points to unexpected changeset 3
    b/bar/@?: 70b10c6b17b7 not in parent-directory manifest
    b/bar/orange/@?: rev 2 points to unexpected changeset 3
    (expected None)
    b/bar/orange/fly/@?: rev 2 points to unexpected changeset 3
    (expected None)
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
   2 warnings encountered!
   8 integrity errors encountered!
   (first damaged changeset appears to be 2)
   [1]
   $ cp -R .hg/store-newcopy/. .hg/store
 
 Test cloning a treemanifest repo over http.
   $ hg serve -p $HGPORT -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 We can clone even with the knob turned off and we'll get a treemanifest repo.
   $ hg clone --config experimental.treemanifest=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deepclone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
 No server errors.
   $ cat deeprepo/errors.log
 requires got updated to include treemanifest
   $ cat deepclone/.hg/requires | grep treemanifest
   treemanifest
 Tree manifest revlogs exist.
   $ find deepclone/.hg/store/meta | sort
   deepclone/.hg/store/meta
   deepclone/.hg/store/meta/b
   deepclone/.hg/store/meta/b/00manifest.i
   deepclone/.hg/store/meta/b/bar
   deepclone/.hg/store/meta/b/bar/00manifest.i
   deepclone/.hg/store/meta/b/bar/orange
   deepclone/.hg/store/meta/b/bar/orange/00manifest.i
   deepclone/.hg/store/meta/b/bar/orange/fly
   deepclone/.hg/store/meta/b/bar/orange/fly/00manifest.i
   deepclone/.hg/store/meta/b/foo
   deepclone/.hg/store/meta/b/foo/00manifest.i
   deepclone/.hg/store/meta/b/foo/apple
   deepclone/.hg/store/meta/b/foo/apple/00manifest.i
   deepclone/.hg/store/meta/b/foo/apple/bees
   deepclone/.hg/store/meta/b/foo/apple/bees/00manifest.i
   deepclone/.hg/store/meta/~2e_a
   deepclone/.hg/store/meta/~2e_a/00manifest.i
 Verify passes.
   $ cd deepclone
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
   $ cd ..
 
 Create clones using old repo formats to use in later tests
   $ hg clone --config format.usestore=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deeprepo-basicstore
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd deeprepo-basicstore
   $ grep store .hg/requires
   [1]
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
   $ hg clone --config format.usefncache=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deeprepo-encodedstore
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd deeprepo-encodedstore
   $ grep fncache .hg/requires
   [1]
   $ hg serve -p $HGPORT2 -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 
 Local clone with basicstore
   $ hg clone -U deeprepo-basicstore local-clone-basicstore
   $ hg -R local-clone-basicstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Local clone with encodedstore
   $ hg clone -U deeprepo-encodedstore local-clone-encodedstore
   $ hg -R local-clone-encodedstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Local clone with fncachestore
   $ hg clone -U deeprepo local-clone-fncachestore
   $ hg -R local-clone-fncachestore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with basicstore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT1 stream-clone-basicstore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-basicstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with encodedstore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT2 stream-clone-encodedstore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-encodedstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with fncachestore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT stream-clone-fncachestore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-fncachestore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Packed bundle
   $ hg -R deeprepo debugcreatestreamclonebundle repo-packed.hg
   writing 5330 bytes for 18 files
   bundle requirements: generaldelta, revlogv1, treemanifest
   $ hg debugbundle --spec repo-packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlogv1%2Ctreemanifest
 
 Bundle with changegroup2 is not supported
 
   $ hg -R deeprepo bundle --all -t v2 deeprepo.bundle
   abort: repository does not support bundle version 02
   [255]
 
 Pull does not include changegroup for manifest the client already has from
 other branch
 
   $ mkdir grafted-dir-repo
   $ cd grafted-dir-repo
   $ hg --config experimental.treemanifest=1 init
   $ mkdir dir
   $ echo a > dir/file
   $ echo a > file
   $ hg ci -Am initial
   adding dir/file
   adding file
   $ echo b > dir/file
   $ hg ci -m updated
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert -r tip dir/
   reverting dir/file
   $ echo b > file # to make sure root manifest is sent
   $ hg ci -m grafted
   created new head
   $ cd ..
 
   $ hg --config experimental.treemanifest=1 clone --pull -r 1 \
   >   grafted-dir-repo grafted-dir-repo-clone
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   new changesets d84f4c419457:09ab742f3b0f
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd grafted-dir-repo-clone
   $ hg pull -r 2
   pulling from $TESTTMP/grafted-dir-repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 73699489fb7c
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Committing a empty commit does not duplicate root treemanifest
   $ echo z >> z
   $ hg commit -Aqm 'pre-empty commit'
   $ hg rm z
   $ hg commit --amend -m 'empty commit'
   saved backup bundle to $TESTTMP/grafted-dir-repo-clone/.hg/strip-backup/cb99d5717cea-9e3b6b02-amend.hg
   $ hg log -r 'tip + tip^' -T '{manifest}\n'
   1:678d3574b88c
   1:678d3574b88c
   $ hg --config extensions.strip= strip -r . -q