bundle2: store changeset count when creating file bundles

The bundle2 changegroup part has an advisory param saying how many
changesets are in the part. Before this patch, we were setting
this part when generating bundle2 parts via the wire protocol but
not when generating local bundle2 files.

A side effect of not setting the changeset count part is that progress
bars don't work when applying changesets. As the tests show, this
impacted clone bundles, shelve, backup bundles, `hg unbundle`, and
anything touching bundle2 files.

This patch adds a backdoor to allow us to pass state from
changegroup generation into the unbundler. We store the number
of changesets in the changegroup in this state and use it to
populate the aforementioned advisory part parameter when generating
the bundle2 bundle.

I concede that I'm not thrilled by how state is being passed in
changegroup.py (it feels a bit hacky). I would love to overhaul the
rather confusing set of functions in changegroup.py with something that
passes rich objects around instead of e.g. low-level generators.
However, given the code freeze for 3.9 is imminent, I'd rather not
undertake this endeavor right now. This feels like the easiest way
to get the parameter added to the changegroup part.

mercurial/bundle2.py

@@ -1,1608 +1,1611 b''
 # bundle2.py - generic container format to transmit arbitrary data.
 #
 # Copyright 2013 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """Handling of the new bundle2 format
 
 The goal of bundle2 is to act as an atomically packet to transmit a set of
 payloads in an application agnostic way. It consist in a sequence of "parts"
 that will be handed to and processed by the application layer.
 
 
 General format architecture
 ===========================
 
 The format is architectured as follow
 
  - magic string
  - stream level parameters
  - payload parts (any number)
  - end of stream marker.
 
 the Binary format
 ============================
 
 All numbers are unsigned and big-endian.
 
 stream level parameters
 ------------------------
 
 Binary format is as follow
 
 :params size: int32
 
   The total number of Bytes used by the parameters
 
 :params value: arbitrary number of Bytes
 
   A blob of `params size` containing the serialized version of all stream level
   parameters.
 
   The blob contains a space separated list of parameters. Parameters with value
   are stored in the form `<name>=<value>`. Both name and value are urlquoted.
 
   Empty name are obviously forbidden.
 
   Name MUST start with a letter. If this first letter is lower case, the
   parameter is advisory and can be safely ignored. However when the first
   letter is capital, the parameter is mandatory and the bundling process MUST
   stop if he is not able to proceed it.
 
   Stream parameters use a simple textual format for two main reasons:
 
   - Stream level parameters should remain simple and we want to discourage any
     crazy usage.
   - Textual data allow easy human inspection of a bundle2 header in case of
     troubles.
 
   Any Applicative level options MUST go into a bundle2 part instead.
 
 Payload part
 ------------------------
 
 Binary format is as follow
 
 :header size: int32
 
   The total number of Bytes used by the part header. When the header is empty
   (size = 0) this is interpreted as the end of stream marker.
 
 :header:
 
     The header defines how to interpret the part. It contains two piece of
     data: the part type, and the part parameters.
 
     The part type is used to route an application level handler, that can
     interpret payload.
 
     Part parameters are passed to the application level handler.  They are
     meant to convey information that will help the application level object to
     interpret the part payload.
 
     The binary format of the header is has follow
 
     :typesize: (one byte)
 
     :parttype: alphanumerical part name (restricted to [a-zA-Z0-9_:-]*)
 
     :partid: A 32bits integer (unique in the bundle) that can be used to refer
              to this part.
 
     :parameters:
 
         Part's parameter may have arbitrary content, the binary structure is::
 
             <mandatory-count><advisory-count><param-sizes><param-data>
 
         :mandatory-count: 1 byte, number of mandatory parameters
 
         :advisory-count:  1 byte, number of advisory parameters
 
         :param-sizes:
 
             N couple of bytes, where N is the total number of parameters. Each
             couple contains (<size-of-key>, <size-of-value) for one parameter.
 
         :param-data:
 
             A blob of bytes from which each parameter key and value can be
             retrieved using the list of size couples stored in the previous
             field.
 
             Mandatory parameters comes first, then the advisory ones.
 
             Each parameter's key MUST be unique within the part.
 
 :payload:
 
     payload is a series of `<chunksize><chunkdata>`.
 
     `chunksize` is an int32, `chunkdata` are plain bytes (as much as
     `chunksize` says)` The payload part is concluded by a zero size chunk.
 
     The current implementation always produces either zero or one chunk.
     This is an implementation limitation that will ultimately be lifted.
 
     `chunksize` can be negative to trigger special case processing. No such
     processing is in place yet.
 
 Bundle processing
 ============================
 
 Each part is processed in order using a "part handler". Handler are registered
 for a certain part type.
 
 The matching of a part to its handler is case insensitive. The case of the
 part type is used to know if a part is mandatory or advisory. If the Part type
 contains any uppercase char it is considered mandatory. When no handler is
 known for a Mandatory part, the process is aborted and an exception is raised.
 If the part is advisory and no handler is known, the part is ignored. When the
 process is aborted, the full bundle is still read from the stream to keep the
 channel usable. But none of the part read from an abort are processed. In the
 future, dropping the stream may become an option for channel we do not care to
 preserve.
 """
 
 from __future__ import absolute_import
 
 import errno
 import re
 import string
 import struct
 import sys
 
 from .i18n import _
 from . import (
     changegroup,
     error,
     obsolete,
     pushkey,
     tags,
     url,
     util,
 )
 
 urlerr = util.urlerr
 urlreq = util.urlreq
 
 _pack = struct.pack
 _unpack = struct.unpack
 
 _fstreamparamsize = '>i'
 _fpartheadersize = '>i'
 _fparttypesize = '>B'
 _fpartid = '>I'
 _fpayloadsize = '>i'
 _fpartparamcount = '>BB'
 
 preferedchunksize = 4096
 
 _parttypeforbidden = re.compile('[^a-zA-Z0-9_:-]')
 
 def outdebug(ui, message):
     """debug regarding output stream (bundling)"""
     if ui.configbool('devel', 'bundle2.debug', False):
         ui.debug('bundle2-output: %s\n' % message)
 
 def indebug(ui, message):
     """debug on input stream (unbundling)"""
     if ui.configbool('devel', 'bundle2.debug', False):
         ui.debug('bundle2-input: %s\n' % message)
 
 def validateparttype(parttype):
     """raise ValueError if a parttype contains invalid character"""
     if _parttypeforbidden.search(parttype):
         raise ValueError(parttype)
 
 def _makefpartparamsizes(nbparams):
     """return a struct format to read part parameter sizes
 
     The number parameters is variable so we need to build that format
     dynamically.
     """
     return '>'+('BB'*nbparams)
 
 parthandlermapping = {}
 
 def parthandler(parttype, params=()):
     """decorator that register a function as a bundle2 part handler
 
     eg::
 
         @parthandler('myparttype', ('mandatory', 'param', 'handled'))
         def myparttypehandler(...):
             '''process a part of type "my part".'''
             ...
     """
     validateparttype(parttype)
     def _decorator(func):
         lparttype = parttype.lower() # enforce lower case matching.
         assert lparttype not in parthandlermapping
         parthandlermapping[lparttype] = func
         func.params = frozenset(params)
         return func
     return _decorator
 
 class unbundlerecords(object):
     """keep record of what happens during and unbundle
 
     New records are added using `records.add('cat', obj)`. Where 'cat' is a
     category of record and obj is an arbitrary object.
 
     `records['cat']` will return all entries of this category 'cat'.
 
     Iterating on the object itself will yield `('category', obj)` tuples
     for all entries.
 
     All iterations happens in chronological order.
     """
 
     def __init__(self):
         self._categories = {}
         self._sequences = []
         self._replies = {}
 
     def add(self, category, entry, inreplyto=None):
         """add a new record of a given category.
 
         The entry can then be retrieved in the list returned by
         self['category']."""
         self._categories.setdefault(category, []).append(entry)
         self._sequences.append((category, entry))
         if inreplyto is not None:
             self.getreplies(inreplyto).add(category, entry)
 
     def getreplies(self, partid):
         """get the records that are replies to a specific part"""
         return self._replies.setdefault(partid, unbundlerecords())
 
     def __getitem__(self, cat):
         return tuple(self._categories.get(cat, ()))
 
     def __iter__(self):
         return iter(self._sequences)
 
     def __len__(self):
         return len(self._sequences)
 
     def __nonzero__(self):
         return bool(self._sequences)
 
 class bundleoperation(object):
     """an object that represents a single bundling process
 
     Its purpose is to carry unbundle-related objects and states.
 
     A new object should be created at the beginning of each bundle processing.
     The object is to be returned by the processing function.
 
     The object has very little content now it will ultimately contain:
     * an access to the repo the bundle is applied to,
     * a ui object,
     * a way to retrieve a transaction to add changes to the repo,
     * a way to record the result of processing each part,
     * a way to construct a bundle response when applicable.
     """
 
     def __init__(self, repo, transactiongetter, captureoutput=True):
         self.repo = repo
         self.ui = repo.ui
         self.records = unbundlerecords()
         self.gettransaction = transactiongetter
         self.reply = None
         self.captureoutput = captureoutput
 
 class TransactionUnavailable(RuntimeError):
     pass
 
 def _notransaction():
     """default method to get a transaction while processing a bundle
 
     Raise an exception to highlight the fact that no transaction was expected
     to be created"""
     raise TransactionUnavailable()
 
 def applybundle(repo, unbundler, tr, source=None, url=None, op=None):
     # transform me into unbundler.apply() as soon as the freeze is lifted
     tr.hookargs['bundle2'] = '1'
     if source is not None and 'source' not in tr.hookargs:
         tr.hookargs['source'] = source
     if url is not None and 'url' not in tr.hookargs:
         tr.hookargs['url'] = url
     return processbundle(repo, unbundler, lambda: tr, op=op)
 
 def processbundle(repo, unbundler, transactiongetter=None, op=None):
     """This function process a bundle, apply effect to/from a repo
 
     It iterates over each part then searches for and uses the proper handling
     code to process the part. Parts are processed in order.
 
     This is very early version of this function that will be strongly reworked
     before final usage.
 
     Unknown Mandatory part will abort the process.
 
     It is temporarily possible to provide a prebuilt bundleoperation to the
     function. This is used to ensure output is properly propagated in case of
     an error during the unbundling. This output capturing part will likely be
     reworked and this ability will probably go away in the process.
     """
     if op is None:
         if transactiongetter is None:
             transactiongetter = _notransaction
         op = bundleoperation(repo, transactiongetter)
     # todo:
     # - replace this is a init function soon.
     # - exception catching
     unbundler.params
     if repo.ui.debugflag:
         msg = ['bundle2-input-bundle:']
         if unbundler.params:
             msg.append(' %i params')
         if op.gettransaction is None:
             msg.append(' no-transaction')
         else:
             msg.append(' with-transaction')
         msg.append('\n')
         repo.ui.debug(''.join(msg))
     iterparts = enumerate(unbundler.iterparts())
     part = None
     nbpart = 0
     try:
         for nbpart, part in iterparts:
             _processpart(op, part)
     except BaseException as exc:
         for nbpart, part in iterparts:
             # consume the bundle content
             part.seek(0, 2)
         # Small hack to let caller code distinguish exceptions from bundle2
         # processing from processing the old format. This is mostly
         # needed to handle different return codes to unbundle according to the
         # type of bundle. We should probably clean up or drop this return code
         # craziness in a future version.
         exc.duringunbundle2 = True
         salvaged = []
         replycaps = None
         if op.reply is not None:
             salvaged = op.reply.salvageoutput()
             replycaps = op.reply.capabilities
         exc._replycaps = replycaps
         exc._bundle2salvagedoutput = salvaged
         raise
     finally:
         repo.ui.debug('bundle2-input-bundle: %i parts total\n' % nbpart)
 
     return op
 
 def _processpart(op, part):
     """process a single part from a bundle
 
     The part is guaranteed to have been fully consumed when the function exits
     (even if an exception is raised)."""
     status = 'unknown' # used by debug output
     try:
         try:
             handler = parthandlermapping.get(part.type)
             if handler is None:
                 status = 'unsupported-type'
                 raise error.BundleUnknownFeatureError(parttype=part.type)
             indebug(op.ui, 'found a handler for part %r' % part.type)
             unknownparams = part.mandatorykeys - handler.params
             if unknownparams:
                 unknownparams = list(unknownparams)
                 unknownparams.sort()
                 status = 'unsupported-params (%s)' % unknownparams
                 raise error.BundleUnknownFeatureError(parttype=part.type,
                                                       params=unknownparams)
             status = 'supported'
         except error.BundleUnknownFeatureError as exc:
             if part.mandatory: # mandatory parts
                 raise
             indebug(op.ui, 'ignoring unsupported advisory part %s' % exc)
             return # skip to part processing
         finally:
             if op.ui.debugflag:
                 msg = ['bundle2-input-part: "%s"' % part.type]
                 if not part.mandatory:
                     msg.append(' (advisory)')
                 nbmp = len(part.mandatorykeys)
                 nbap = len(part.params) - nbmp
                 if nbmp or nbap:
                     msg.append(' (params:')
                     if nbmp:
                         msg.append(' %i mandatory' % nbmp)
                     if nbap:
                         msg.append(' %i advisory' % nbmp)
                     msg.append(')')
                 msg.append(' %s\n' % status)
                 op.ui.debug(''.join(msg))
 
         # handler is called outside the above try block so that we don't
         # risk catching KeyErrors from anything other than the
         # parthandlermapping lookup (any KeyError raised by handler()
         # itself represents a defect of a different variety).
         output = None
         if op.captureoutput and op.reply is not None:
             op.ui.pushbuffer(error=True, subproc=True)
             output = ''
         try:
             handler(op, part)
         finally:
             if output is not None:
                 output = op.ui.popbuffer()
             if output:
                 outpart = op.reply.newpart('output', data=output,
                                            mandatory=False)
                 outpart.addparam('in-reply-to', str(part.id), mandatory=False)
     finally:
         # consume the part content to not corrupt the stream.
         part.seek(0, 2)
 
 
 def decodecaps(blob):
     """decode a bundle2 caps bytes blob into a dictionary
 
     The blob is a list of capabilities (one per line)
     Capabilities may have values using a line of the form::
 
         capability=value1,value2,value3
 
     The values are always a list."""
     caps = {}
     for line in blob.splitlines():
         if not line:
             continue
         if '=' not in line:
             key, vals = line, ()
         else:
             key, vals = line.split('=', 1)
             vals = vals.split(',')
         key = urlreq.unquote(key)
         vals = [urlreq.unquote(v) for v in vals]
         caps[key] = vals
     return caps
 
 def encodecaps(caps):
     """encode a bundle2 caps dictionary into a bytes blob"""
     chunks = []
     for ca in sorted(caps):
         vals = caps[ca]
         ca = urlreq.quote(ca)
         vals = [urlreq.quote(v) for v in vals]
         if vals:
             ca = "%s=%s" % (ca, ','.join(vals))
         chunks.append(ca)
     return '\n'.join(chunks)
 
 bundletypes = {
     "": ("", None),       # only when using unbundle on ssh and old http servers
                           # since the unification ssh accepts a header but there
                           # is no capability signaling it.
     "HG20": (), # special-cased below
     "HG10UN": ("HG10UN", None),
     "HG10BZ": ("HG10", 'BZ'),
     "HG10GZ": ("HG10GZ", 'GZ'),
 }
 
 # hgweb uses this list to communicate its preferred type
 bundlepriority = ['HG10GZ', 'HG10BZ', 'HG10UN']
 
 class bundle20(object):
     """represent an outgoing bundle2 container
 
     Use the `addparam` method to add stream level parameter. and `newpart` to
     populate it. Then call `getchunks` to retrieve all the binary chunks of
     data that compose the bundle2 container."""
 
     _magicstring = 'HG20'
 
     def __init__(self, ui, capabilities=()):
         self.ui = ui
         self._params = []
         self._parts = []
         self.capabilities = dict(capabilities)
         self._compressor = util.compressors[None]()
 
     def setcompression(self, alg):
         """setup core part compression to <alg>"""
         if alg is None:
             return
         assert not any(n.lower() == 'Compression' for n, v in self._params)
         self.addparam('Compression', alg)
         self._compressor = util.compressors[alg]()
 
     @property
     def nbparts(self):
         """total number of parts added to the bundler"""
         return len(self._parts)
 
     # methods used to defines the bundle2 content
     def addparam(self, name, value=None):
         """add a stream level parameter"""
         if not name:
             raise ValueError('empty parameter name')
         if name[0] not in string.letters:
             raise ValueError('non letter first character: %r' % name)
         self._params.append((name, value))
 
     def addpart(self, part):
         """add a new part to the bundle2 container
 
         Parts contains the actual applicative payload."""
         assert part.id is None
         part.id = len(self._parts) # very cheap counter
         self._parts.append(part)
 
     def newpart(self, typeid, *args, **kwargs):
         """create a new part and add it to the containers
 
         As the part is directly added to the containers. For now, this means
         that any failure to properly initialize the part after calling
         ``newpart`` should result in a failure of the whole bundling process.
 
         You can still fall back to manually create and add if you need better
         control."""
         part = bundlepart(typeid, *args, **kwargs)
         self.addpart(part)
         return part
 
     # methods used to generate the bundle2 stream
     def getchunks(self):
         if self.ui.debugflag:
             msg = ['bundle2-output-bundle: "%s",' % self._magicstring]
             if self._params:
                 msg.append(' (%i params)' % len(self._params))
             msg.append(' %i parts total\n' % len(self._parts))
             self.ui.debug(''.join(msg))
         outdebug(self.ui, 'start emission of %s stream' % self._magicstring)
         yield self._magicstring
         param = self._paramchunk()
         outdebug(self.ui, 'bundle parameter: %s' % param)
         yield _pack(_fstreamparamsize, len(param))
         if param:
             yield param
         # starting compression
         for chunk in self._getcorechunk():
             yield self._compressor.compress(chunk)
         yield self._compressor.flush()
 
     def _paramchunk(self):
         """return a encoded version of all stream parameters"""
         blocks = []
         for par, value in self._params:
             par = urlreq.quote(par)
             if value is not None:
                 value = urlreq.quote(value)
                 par = '%s=%s' % (par, value)
             blocks.append(par)
         return ' '.join(blocks)
 
     def _getcorechunk(self):
         """yield chunk for the core part of the bundle
 
         (all but headers and parameters)"""
         outdebug(self.ui, 'start of parts')
         for part in self._parts:
             outdebug(self.ui, 'bundle part: "%s"' % part.type)
             for chunk in part.getchunks(ui=self.ui):
                 yield chunk
         outdebug(self.ui, 'end of bundle')
         yield _pack(_fpartheadersize, 0)
 
 
     def salvageoutput(self):
         """return a list with a copy of all output parts in the bundle
 
         This is meant to be used during error handling to make sure we preserve
         server output"""
         salvaged = []
         for part in self._parts:
             if part.type.startswith('output'):
                 salvaged.append(part.copy())
         return salvaged
 
 
 class unpackermixin(object):
     """A mixin to extract bytes and struct data from a stream"""
 
     def __init__(self, fp):
         self._fp = fp
         self._seekable = (util.safehasattr(fp, 'seek') and
                           util.safehasattr(fp, 'tell'))
 
     def _unpack(self, format):
         """unpack this struct format from the stream"""
         data = self._readexact(struct.calcsize(format))
         return _unpack(format, data)
 
     def _readexact(self, size):
         """read exactly <size> bytes from the stream"""
         return changegroup.readexactly(self._fp, size)
 
     def seek(self, offset, whence=0):
         """move the underlying file pointer"""
         if self._seekable:
             return self._fp.seek(offset, whence)
         else:
             raise NotImplementedError(_('File pointer is not seekable'))
 
     def tell(self):
         """return the file offset, or None if file is not seekable"""
         if self._seekable:
             try:
                 return self._fp.tell()
             except IOError as e:
                 if e.errno == errno.ESPIPE:
                     self._seekable = False
                 else:
                     raise
         return None
 
     def close(self):
         """close underlying file"""
         if util.safehasattr(self._fp, 'close'):
             return self._fp.close()
 
 def getunbundler(ui, fp, magicstring=None):
     """return a valid unbundler object for a given magicstring"""
     if magicstring is None:
         magicstring = changegroup.readexactly(fp, 4)
     magic, version = magicstring[0:2], magicstring[2:4]
     if magic != 'HG':
         raise error.Abort(_('not a Mercurial bundle'))
     unbundlerclass = formatmap.get(version)
     if unbundlerclass is None:
         raise error.Abort(_('unknown bundle version %s') % version)
     unbundler = unbundlerclass(ui, fp)
     indebug(ui, 'start processing of %s stream' % magicstring)
     return unbundler
 
 class unbundle20(unpackermixin):
     """interpret a bundle2 stream
 
     This class is fed with a binary stream and yields parts through its
     `iterparts` methods."""
 
     _magicstring = 'HG20'
 
     def __init__(self, ui, fp):
         """If header is specified, we do not read it out of the stream."""
         self.ui = ui
         self._decompressor = util.decompressors[None]
         self._compressed = None
         super(unbundle20, self).__init__(fp)
 
     @util.propertycache
     def params(self):
         """dictionary of stream level parameters"""
         indebug(self.ui, 'reading bundle2 stream parameters')
         params = {}
         paramssize = self._unpack(_fstreamparamsize)[0]
         if paramssize < 0:
             raise error.BundleValueError('negative bundle param size: %i'
                                          % paramssize)
         if paramssize:
             params = self._readexact(paramssize)
             params = self._processallparams(params)
         return params
 
     def _processallparams(self, paramsblock):
         """"""
         params = util.sortdict()
         for p in paramsblock.split(' '):
             p = p.split('=', 1)
             p = [urlreq.unquote(i) for i in p]
             if len(p) < 2:
                 p.append(None)
             self._processparam(*p)
             params[p[0]] = p[1]
         return params
 
 
     def _processparam(self, name, value):
         """process a parameter, applying its effect if needed
 
         Parameter starting with a lower case letter are advisory and will be
         ignored when unknown.  Those starting with an upper case letter are
         mandatory and will this function will raise a KeyError when unknown.
 
         Note: no option are currently supported. Any input will be either
               ignored or failing.
         """
         if not name:
             raise ValueError('empty parameter name')
         if name[0] not in string.letters:
             raise ValueError('non letter first character: %r' % name)
         try:
             handler = b2streamparamsmap[name.lower()]
         except KeyError:
             if name[0].islower():
                 indebug(self.ui, "ignoring unknown parameter %r" % name)
             else:
                 raise error.BundleUnknownFeatureError(params=(name,))
         else:
             handler(self, name, value)
 
     def _forwardchunks(self):
         """utility to transfer a bundle2 as binary
 
         This is made necessary by the fact the 'getbundle' command over 'ssh'
         have no way to know then the reply end, relying on the bundle to be
         interpreted to know its end. This is terrible and we are sorry, but we
         needed to move forward to get general delta enabled.
         """
         yield self._magicstring
         assert 'params' not in vars(self)
         paramssize = self._unpack(_fstreamparamsize)[0]
         if paramssize < 0:
             raise error.BundleValueError('negative bundle param size: %i'
                                          % paramssize)
         yield _pack(_fstreamparamsize, paramssize)
         if paramssize:
             params = self._readexact(paramssize)
             self._processallparams(params)
             yield params
             assert self._decompressor is util.decompressors[None]
         # From there, payload might need to be decompressed
         self._fp = self._decompressor(self._fp)
         emptycount = 0
         while emptycount < 2:
             # so we can brainlessly loop
             assert _fpartheadersize == _fpayloadsize
             size = self._unpack(_fpartheadersize)[0]
             yield _pack(_fpartheadersize, size)
             if size:
                 emptycount = 0
             else:
                 emptycount += 1
                 continue
             if size == flaginterrupt:
                 continue
             elif size < 0:
                 raise error.BundleValueError('negative chunk size: %i')
             yield self._readexact(size)
 
 
     def iterparts(self):
         """yield all parts contained in the stream"""
         # make sure param have been loaded
         self.params
         # From there, payload need to be decompressed
         self._fp = self._decompressor(self._fp)
         indebug(self.ui, 'start extraction of bundle2 parts')
         headerblock = self._readpartheader()
         while headerblock is not None:
             part = unbundlepart(self.ui, headerblock, self._fp)
             yield part
             part.seek(0, 2)
             headerblock = self._readpartheader()
         indebug(self.ui, 'end of bundle2 stream')
 
     def _readpartheader(self):
         """reads a part header size and return the bytes blob
 
         returns None if empty"""
         headersize = self._unpack(_fpartheadersize)[0]
         if headersize < 0:
             raise error.BundleValueError('negative part header size: %i'
                                          % headersize)
         indebug(self.ui, 'part header size: %i' % headersize)
         if headersize:
             return self._readexact(headersize)
         return None
 
     def compressed(self):
         self.params # load params
         return self._compressed
 
 formatmap = {'20': unbundle20}
 
 b2streamparamsmap = {}
 
 def b2streamparamhandler(name):
     """register a handler for a stream level parameter"""
     def decorator(func):
         assert name not in formatmap
         b2streamparamsmap[name] = func
         return func
     return decorator
 
 @b2streamparamhandler('compression')
 def processcompression(unbundler, param, value):
     """read compression parameter and install payload decompression"""
     if value not in util.decompressors:
         raise error.BundleUnknownFeatureError(params=(param,),
                                               values=(value,))
     unbundler._decompressor = util.decompressors[value]
     if value is not None:
         unbundler._compressed = True
 
 class bundlepart(object):
     """A bundle2 part contains application level payload
 
     The part `type` is used to route the part to the application level
     handler.
 
     The part payload is contained in ``part.data``. It could be raw bytes or a
     generator of byte chunks.
 
     You can add parameters to the part using the ``addparam`` method.
     Parameters can be either mandatory (default) or advisory. Remote side
     should be able to safely ignore the advisory ones.
 
     Both data and parameters cannot be modified after the generation has begun.
     """
 
     def __init__(self, parttype, mandatoryparams=(), advisoryparams=(),
                  data='', mandatory=True):
         validateparttype(parttype)
         self.id = None
         self.type = parttype
         self._data = data
         self._mandatoryparams = list(mandatoryparams)
         self._advisoryparams = list(advisoryparams)
         # checking for duplicated entries
         self._seenparams = set()
         for pname, __ in self._mandatoryparams + self._advisoryparams:
             if pname in self._seenparams:
                 raise RuntimeError('duplicated params: %s' % pname)
             self._seenparams.add(pname)
         # status of the part's generation:
         # - None: not started,
         # - False: currently generated,
         # - True: generation done.
         self._generated = None
         self.mandatory = mandatory
 
     def copy(self):
         """return a copy of the part
 
         The new part have the very same content but no partid assigned yet.
         Parts with generated data cannot be copied."""
         assert not util.safehasattr(self.data, 'next')
         return self.__class__(self.type, self._mandatoryparams,
                               self._advisoryparams, self._data, self.mandatory)
 
     # methods used to defines the part content
     @property
     def data(self):
         return self._data
 
     @data.setter
     def data(self, data):
         if self._generated is not None:
             raise error.ReadOnlyPartError('part is being generated')
         self._data = data
 
     @property
     def mandatoryparams(self):
         # make it an immutable tuple to force people through ``addparam``
         return tuple(self._mandatoryparams)
 
     @property
     def advisoryparams(self):
         # make it an immutable tuple to force people through ``addparam``
         return tuple(self._advisoryparams)
 
     def addparam(self, name, value='', mandatory=True):
         if self._generated is not None:
             raise error.ReadOnlyPartError('part is being generated')
         if name in self._seenparams:
             raise ValueError('duplicated params: %s' % name)
         self._seenparams.add(name)
         params = self._advisoryparams
         if mandatory:
             params = self._mandatoryparams
         params.append((name, value))
 
     # methods used to generates the bundle2 stream
     def getchunks(self, ui):
         if self._generated is not None:
             raise RuntimeError('part can only be consumed once')
         self._generated = False
 
         if ui.debugflag:
             msg = ['bundle2-output-part: "%s"' % self.type]
             if not self.mandatory:
                 msg.append(' (advisory)')
             nbmp = len(self.mandatoryparams)
             nbap = len(self.advisoryparams)
             if nbmp or nbap:
                 msg.append(' (params:')
                 if nbmp:
                     msg.append(' %i mandatory' % nbmp)
                 if nbap:
                     msg.append(' %i advisory' % nbmp)
                 msg.append(')')
             if not self.data:
                 msg.append(' empty payload')
             elif util.safehasattr(self.data, 'next'):
                 msg.append(' streamed payload')
             else:
                 msg.append(' %i bytes payload' % len(self.data))
             msg.append('\n')
             ui.debug(''.join(msg))
 
         #### header
         if self.mandatory:
             parttype = self.type.upper()
         else:
             parttype = self.type.lower()
         outdebug(ui, 'part %s: "%s"' % (self.id, parttype))
         ## parttype
         header = [_pack(_fparttypesize, len(parttype)),
                   parttype, _pack(_fpartid, self.id),
                  ]
         ## parameters
         # count
         manpar = self.mandatoryparams
         advpar = self.advisoryparams
         header.append(_pack(_fpartparamcount, len(manpar), len(advpar)))
         # size
         parsizes = []
         for key, value in manpar:
             parsizes.append(len(key))
             parsizes.append(len(value))
         for key, value in advpar:
             parsizes.append(len(key))
             parsizes.append(len(value))
         paramsizes = _pack(_makefpartparamsizes(len(parsizes) / 2), *parsizes)
         header.append(paramsizes)
         # key, value
         for key, value in manpar:
             header.append(key)
             header.append(value)
         for key, value in advpar:
             header.append(key)
             header.append(value)
         ## finalize header
         headerchunk = ''.join(header)
         outdebug(ui, 'header chunk size: %i' % len(headerchunk))
         yield _pack(_fpartheadersize, len(headerchunk))
         yield headerchunk
         ## payload
         try:
             for chunk in self._payloadchunks():
                 outdebug(ui, 'payload chunk size: %i' % len(chunk))
                 yield _pack(_fpayloadsize, len(chunk))
                 yield chunk
         except GeneratorExit:
             # GeneratorExit means that nobody is listening for our
             # results anyway, so just bail quickly rather than trying
             # to produce an error part.
             ui.debug('bundle2-generatorexit\n')
             raise
         except BaseException as exc:
             # backup exception data for later
             ui.debug('bundle2-input-stream-interrupt: encoding exception %s'
                      % exc)
             exc_info = sys.exc_info()
             msg = 'unexpected error: %s' % exc
             interpart = bundlepart('error:abort', [('message', msg)],
                                    mandatory=False)
             interpart.id = 0
             yield _pack(_fpayloadsize, -1)
             for chunk in interpart.getchunks(ui=ui):
                 yield chunk
             outdebug(ui, 'closing payload chunk')
             # abort current part payload
             yield _pack(_fpayloadsize, 0)
             raise exc_info[0], exc_info[1], exc_info[2]
         # end of payload
         outdebug(ui, 'closing payload chunk')
         yield _pack(_fpayloadsize, 0)
         self._generated = True
 
     def _payloadchunks(self):
         """yield chunks of a the part payload
 
         Exists to handle the different methods to provide data to a part."""
         # we only support fixed size data now.
         # This will be improved in the future.
         if util.safehasattr(self.data, 'next'):
             buff = util.chunkbuffer(self.data)
             chunk = buff.read(preferedchunksize)
             while chunk:
                 yield chunk
                 chunk = buff.read(preferedchunksize)
         elif len(self.data):
             yield self.data
 
 
 flaginterrupt = -1
 
 class interrupthandler(unpackermixin):
     """read one part and process it with restricted capability
 
     This allows to transmit exception raised on the producer size during part
     iteration while the consumer is reading a part.
 
     Part processed in this manner only have access to a ui object,"""
 
     def __init__(self, ui, fp):
         super(interrupthandler, self).__init__(fp)
         self.ui = ui
 
     def _readpartheader(self):
         """reads a part header size and return the bytes blob
 
         returns None if empty"""
         headersize = self._unpack(_fpartheadersize)[0]
         if headersize < 0:
             raise error.BundleValueError('negative part header size: %i'
                                          % headersize)
         indebug(self.ui, 'part header size: %i\n' % headersize)
         if headersize:
             return self._readexact(headersize)
         return None
 
     def __call__(self):
 
         self.ui.debug('bundle2-input-stream-interrupt:'
                       ' opening out of band context\n')
         indebug(self.ui, 'bundle2 stream interruption, looking for a part.')
         headerblock = self._readpartheader()
         if headerblock is None:
             indebug(self.ui, 'no part found during interruption.')
             return
         part = unbundlepart(self.ui, headerblock, self._fp)
         op = interruptoperation(self.ui)
         _processpart(op, part)
         self.ui.debug('bundle2-input-stream-interrupt:'
                       ' closing out of band context\n')
 
 class interruptoperation(object):
     """A limited operation to be use by part handler during interruption
 
     It only have access to an ui object.
     """
 
     def __init__(self, ui):
         self.ui = ui
         self.reply = None
         self.captureoutput = False
 
     @property
     def repo(self):
         raise RuntimeError('no repo access from stream interruption')
 
     def gettransaction(self):
         raise TransactionUnavailable('no repo access from stream interruption')
 
 class unbundlepart(unpackermixin):
     """a bundle part read from a bundle"""
 
     def __init__(self, ui, header, fp):
         super(unbundlepart, self).__init__(fp)
         self.ui = ui
         # unbundle state attr
         self._headerdata = header
         self._headeroffset = 0
         self._initialized = False
         self.consumed = False
         # part data
         self.id = None
         self.type = None
         self.mandatoryparams = None
         self.advisoryparams = None
         self.params = None
         self.mandatorykeys = ()
         self._payloadstream = None
         self._readheader()
         self._mandatory = None
         self._chunkindex = [] #(payload, file) position tuples for chunk starts
         self._pos = 0
 
     def _fromheader(self, size):
         """return the next <size> byte from the header"""
         offset = self._headeroffset
         data = self._headerdata[offset:(offset + size)]
         self._headeroffset = offset + size
         return data
 
     def _unpackheader(self, format):
         """read given format from header
 
         This automatically compute the size of the format to read."""
         data = self._fromheader(struct.calcsize(format))
         return _unpack(format, data)
 
     def _initparams(self, mandatoryparams, advisoryparams):
         """internal function to setup all logic related parameters"""
         # make it read only to prevent people touching it by mistake.
         self.mandatoryparams = tuple(mandatoryparams)
         self.advisoryparams  = tuple(advisoryparams)
         # user friendly UI
         self.params = util.sortdict(self.mandatoryparams)
         self.params.update(self.advisoryparams)
         self.mandatorykeys = frozenset(p[0] for p in mandatoryparams)
 
     def _payloadchunks(self, chunknum=0):
         '''seek to specified chunk and start yielding data'''
         if len(self._chunkindex) == 0:
             assert chunknum == 0, 'Must start with chunk 0'
             self._chunkindex.append((0, super(unbundlepart, self).tell()))
         else:
             assert chunknum < len(self._chunkindex), \
                    'Unknown chunk %d' % chunknum
             super(unbundlepart, self).seek(self._chunkindex[chunknum][1])
 
         pos = self._chunkindex[chunknum][0]
         payloadsize = self._unpack(_fpayloadsize)[0]
         indebug(self.ui, 'payload chunk size: %i' % payloadsize)
         while payloadsize:
             if payloadsize == flaginterrupt:
                 # interruption detection, the handler will now read a
                 # single part and process it.
                 interrupthandler(self.ui, self._fp)()
             elif payloadsize < 0:
                 msg = 'negative payload chunk size: %i' %  payloadsize
                 raise error.BundleValueError(msg)
             else:
                 result = self._readexact(payloadsize)
                 chunknum += 1
                 pos += payloadsize
                 if chunknum == len(self._chunkindex):
                     self._chunkindex.append((pos,
                                              super(unbundlepart, self).tell()))
                 yield result
             payloadsize = self._unpack(_fpayloadsize)[0]
             indebug(self.ui, 'payload chunk size: %i' % payloadsize)
 
     def _findchunk(self, pos):
         '''for a given payload position, return a chunk number and offset'''
         for chunk, (ppos, fpos) in enumerate(self._chunkindex):
             if ppos == pos:
                 return chunk, 0
             elif ppos > pos:
                 return chunk - 1, pos - self._chunkindex[chunk - 1][0]
         raise ValueError('Unknown chunk')
 
     def _readheader(self):
         """read the header and setup the object"""
         typesize = self._unpackheader(_fparttypesize)[0]
         self.type = self._fromheader(typesize)
         indebug(self.ui, 'part type: "%s"' % self.type)
         self.id = self._unpackheader(_fpartid)[0]
         indebug(self.ui, 'part id: "%s"' % self.id)
         # extract mandatory bit from type
         self.mandatory = (self.type != self.type.lower())
         self.type = self.type.lower()
         ## reading parameters
         # param count
         mancount, advcount = self._unpackheader(_fpartparamcount)
         indebug(self.ui, 'part parameters: %i' % (mancount + advcount))
         # param size
         fparamsizes = _makefpartparamsizes(mancount + advcount)
         paramsizes = self._unpackheader(fparamsizes)
         # make it a list of couple again
         paramsizes = zip(paramsizes[::2], paramsizes[1::2])
         # split mandatory from advisory
         mansizes = paramsizes[:mancount]
         advsizes = paramsizes[mancount:]
         # retrieve param value
         manparams = []
         for key, value in mansizes:
             manparams.append((self._fromheader(key), self._fromheader(value)))
         advparams = []
         for key, value in advsizes:
             advparams.append((self._fromheader(key), self._fromheader(value)))
         self._initparams(manparams, advparams)
         ## part payload
         self._payloadstream = util.chunkbuffer(self._payloadchunks())
         # we read the data, tell it
         self._initialized = True
 
     def read(self, size=None):
         """read payload data"""
         if not self._initialized:
             self._readheader()
         if size is None:
             data = self._payloadstream.read()
         else:
             data = self._payloadstream.read(size)
         self._pos += len(data)
         if size is None or len(data) < size:
             if not self.consumed and self._pos:
                 self.ui.debug('bundle2-input-part: total payload size %i\n'
                               % self._pos)
             self.consumed = True
         return data
 
     def tell(self):
         return self._pos
 
     def seek(self, offset, whence=0):
         if whence == 0:
             newpos = offset
         elif whence == 1:
             newpos = self._pos + offset
         elif whence == 2:
             if not self.consumed:
                 self.read()
             newpos = self._chunkindex[-1][0] - offset
         else:
             raise ValueError('Unknown whence value: %r' % (whence,))
 
         if newpos > self._chunkindex[-1][0] and not self.consumed:
             self.read()
         if not 0 <= newpos <= self._chunkindex[-1][0]:
             raise ValueError('Offset out of range')
 
         if self._pos != newpos:
             chunk, internaloffset = self._findchunk(newpos)
             self._payloadstream = util.chunkbuffer(self._payloadchunks(chunk))
             adjust = self.read(internaloffset)
             if len(adjust) != internaloffset:
                 raise error.Abort(_('Seek failed\n'))
             self._pos = newpos
 
 # These are only the static capabilities.
 # Check the 'getrepocaps' function for the rest.
 capabilities = {'HG20': (),
                 'error': ('abort', 'unsupportedcontent', 'pushraced',
                           'pushkey'),
                 'listkeys': (),
                 'pushkey': (),
                 'digests': tuple(sorted(util.DIGESTS.keys())),
                 'remote-changegroup': ('http', 'https'),
                 'hgtagsfnodes': (),
                }
 
 def getrepocaps(repo, allowpushback=False):
     """return the bundle2 capabilities for a given repo
 
     Exists to allow extensions (like evolution) to mutate the capabilities.
     """
     caps = capabilities.copy()
     caps['changegroup'] = tuple(sorted(
         changegroup.supportedincomingversions(repo)))
     if obsolete.isenabled(repo, obsolete.exchangeopt):
         supportedformat = tuple('V%i' % v for v in obsolete.formats)
         caps['obsmarkers'] = supportedformat
     if allowpushback:
         caps['pushback'] = ()
     return caps
 
 def bundle2caps(remote):
     """return the bundle capabilities of a peer as dict"""
     raw = remote.capable('bundle2')
     if not raw and raw != '':
         return {}
     capsblob = urlreq.unquote(remote.capable('bundle2'))
     return decodecaps(capsblob)
 
 def obsmarkersversion(caps):
     """extract the list of supported obsmarkers versions from a bundle2caps dict
     """
     obscaps = caps.get('obsmarkers', ())
     return [int(c[1:]) for c in obscaps if c.startswith('V')]
 
 def writebundle(ui, cg, filename, bundletype, vfs=None, compression=None):
     """Write a bundle file and return its filename.
 
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     bz2 compression can be turned off.
     The bundle file will be deleted in case of errors.
     """
 
     if bundletype == "HG20":
         bundle = bundle20(ui)
         bundle.setcompression(compression)
         part = bundle.newpart('changegroup', data=cg.getchunks())
         part.addparam('version', cg.version)
+        if 'clcount' in cg.extras:
+            part.addparam('nbchanges', str(cg.extras['clcount']),
+                          mandatory=False)
         chunkiter = bundle.getchunks()
     else:
         # compression argument is only for the bundle2 case
         assert compression is None
         if cg.version != '01':
             raise error.Abort(_('old bundle types only supports v1 '
                                 'changegroups'))
         header, comp = bundletypes[bundletype]
         if comp not in util.compressors:
             raise error.Abort(_('unknown stream compression type: %s')
                               % comp)
         z = util.compressors[comp]()
         subchunkiter = cg.getchunks()
         def chunkiter():
             yield header
             for chunk in subchunkiter:
                 yield z.compress(chunk)
             yield z.flush()
         chunkiter = chunkiter()
 
     # parse the changegroup data, otherwise we will block
     # in case of sshrepo because we don't know the end of the stream
     return changegroup.writechunks(ui, chunkiter, filename, vfs=vfs)
 
 @parthandler('changegroup', ('version', 'nbchanges', 'treemanifest'))
 def handlechangegroup(op, inpart):
     """apply a changegroup part on the repo
 
     This is a very early implementation that will massive rework before being
     inflicted to any end-user.
     """
     # Make sure we trigger a transaction creation
     #
     # The addchangegroup function will get a transaction object by itself, but
     # we need to make sure we trigger the creation of a transaction object used
     # for the whole processing scope.
     op.gettransaction()
     unpackerversion = inpart.params.get('version', '01')
     # We should raise an appropriate exception here
     cg = changegroup.getunbundler(unpackerversion, inpart, None)
     # the source and url passed here are overwritten by the one contained in
     # the transaction.hookargs argument. So 'bundle2' is a placeholder
     nbchangesets = None
     if 'nbchanges' in inpart.params:
         nbchangesets = int(inpart.params.get('nbchanges'))
     if ('treemanifest' in inpart.params and
         'treemanifest' not in op.repo.requirements):
         if len(op.repo.changelog) != 0:
             raise error.Abort(_(
                 "bundle contains tree manifests, but local repo is "
                 "non-empty and does not use tree manifests"))
         op.repo.requirements.add('treemanifest')
         op.repo._applyopenerreqs()
         op.repo._writerequirements()
     ret = cg.apply(op.repo, 'bundle2', 'bundle2', expectedtotal=nbchangesets)
     op.records.add('changegroup', {'return': ret})
     if op.reply is not None:
         # This is definitely not the final form of this
         # return. But one need to start somewhere.
         part = op.reply.newpart('reply:changegroup', mandatory=False)
         part.addparam('in-reply-to', str(inpart.id), mandatory=False)
         part.addparam('return', '%i' % ret, mandatory=False)
     assert not inpart.read()
 
 _remotechangegroupparams = tuple(['url', 'size', 'digests'] +
     ['digest:%s' % k for k in util.DIGESTS.keys()])
 @parthandler('remote-changegroup', _remotechangegroupparams)
 def handleremotechangegroup(op, inpart):
     """apply a bundle10 on the repo, given an url and validation information
 
     All the information about the remote bundle to import are given as
     parameters. The parameters include:
       - url: the url to the bundle10.
       - size: the bundle10 file size. It is used to validate what was
         retrieved by the client matches the server knowledge about the bundle.
       - digests: a space separated list of the digest types provided as
         parameters.
       - digest:<digest-type>: the hexadecimal representation of the digest with
         that name. Like the size, it is used to validate what was retrieved by
         the client matches what the server knows about the bundle.
 
     When multiple digest types are given, all of them are checked.
     """
     try:
         raw_url = inpart.params['url']
     except KeyError:
         raise error.Abort(_('remote-changegroup: missing "%s" param') % 'url')
     parsed_url = util.url(raw_url)
     if parsed_url.scheme not in capabilities['remote-changegroup']:
         raise error.Abort(_('remote-changegroup does not support %s urls') %
             parsed_url.scheme)
 
     try:
         size = int(inpart.params['size'])
     except ValueError:
         raise error.Abort(_('remote-changegroup: invalid value for param "%s"')
             % 'size')
     except KeyError:
         raise error.Abort(_('remote-changegroup: missing "%s" param') % 'size')
 
     digests = {}
     for typ in inpart.params.get('digests', '').split():
         param = 'digest:%s' % typ
         try:
             value = inpart.params[param]
         except KeyError:
             raise error.Abort(_('remote-changegroup: missing "%s" param') %
                 param)
         digests[typ] = value
 
     real_part = util.digestchecker(url.open(op.ui, raw_url), size, digests)
 
     # Make sure we trigger a transaction creation
     #
     # The addchangegroup function will get a transaction object by itself, but
     # we need to make sure we trigger the creation of a transaction object used
     # for the whole processing scope.
     op.gettransaction()
     from . import exchange
     cg = exchange.readbundle(op.repo.ui, real_part, raw_url)
     if not isinstance(cg, changegroup.cg1unpacker):
         raise error.Abort(_('%s: not a bundle version 1.0') %
             util.hidepassword(raw_url))
     ret = cg.apply(op.repo, 'bundle2', 'bundle2')
     op.records.add('changegroup', {'return': ret})
     if op.reply is not None:
         # This is definitely not the final form of this
         # return. But one need to start somewhere.
         part = op.reply.newpart('reply:changegroup')
         part.addparam('in-reply-to', str(inpart.id), mandatory=False)
         part.addparam('return', '%i' % ret, mandatory=False)
     try:
         real_part.validate()
     except error.Abort as e:
         raise error.Abort(_('bundle at %s is corrupted:\n%s') %
             (util.hidepassword(raw_url), str(e)))
     assert not inpart.read()
 
 @parthandler('reply:changegroup', ('return', 'in-reply-to'))
 def handlereplychangegroup(op, inpart):
     ret = int(inpart.params['return'])
     replyto = int(inpart.params['in-reply-to'])
     op.records.add('changegroup', {'return': ret}, replyto)
 
 @parthandler('check:heads')
 def handlecheckheads(op, inpart):
     """check that head of the repo did not change
 
     This is used to detect a push race when using unbundle.
     This replaces the "heads" argument of unbundle."""
     h = inpart.read(20)
     heads = []
     while len(h) == 20:
         heads.append(h)
         h = inpart.read(20)
     assert not h
     # Trigger a transaction so that we are guaranteed to have the lock now.
     if op.ui.configbool('experimental', 'bundle2lazylocking'):
         op.gettransaction()
     if sorted(heads) != sorted(op.repo.heads()):
         raise error.PushRaced('repository changed while pushing - '
                               'please try again')
 
 @parthandler('output')
 def handleoutput(op, inpart):
     """forward output captured on the server to the client"""
     for line in inpart.read().splitlines():
         op.ui.status(('remote: %s\n' % line))
 
 @parthandler('replycaps')
 def handlereplycaps(op, inpart):
     """Notify that a reply bundle should be created
 
     The payload contains the capabilities information for the reply"""
     caps = decodecaps(inpart.read())
     if op.reply is None:
         op.reply = bundle20(op.ui, caps)
 
 class AbortFromPart(error.Abort):
     """Sub-class of Abort that denotes an error from a bundle2 part."""
 
 @parthandler('error:abort', ('message', 'hint'))
 def handleerrorabort(op, inpart):
     """Used to transmit abort error over the wire"""
     raise AbortFromPart(inpart.params['message'],
                         hint=inpart.params.get('hint'))
 
 @parthandler('error:pushkey', ('namespace', 'key', 'new', 'old', 'ret',
                                'in-reply-to'))
 def handleerrorpushkey(op, inpart):
     """Used to transmit failure of a mandatory pushkey over the wire"""
     kwargs = {}
     for name in ('namespace', 'key', 'new', 'old', 'ret'):
         value = inpart.params.get(name)
         if value is not None:
             kwargs[name] = value
     raise error.PushkeyFailed(inpart.params['in-reply-to'], **kwargs)
 
 @parthandler('error:unsupportedcontent', ('parttype', 'params'))
 def handleerrorunsupportedcontent(op, inpart):
     """Used to transmit unknown content error over the wire"""
     kwargs = {}
     parttype = inpart.params.get('parttype')
     if parttype is not None:
         kwargs['parttype'] = parttype
     params = inpart.params.get('params')
     if params is not None:
         kwargs['params'] = params.split('\0')
 
     raise error.BundleUnknownFeatureError(**kwargs)
 
 @parthandler('error:pushraced', ('message',))
 def handleerrorpushraced(op, inpart):
     """Used to transmit push race error over the wire"""
     raise error.ResponseError(_('push failed:'), inpart.params['message'])
 
 @parthandler('listkeys', ('namespace',))
 def handlelistkeys(op, inpart):
     """retrieve pushkey namespace content stored in a bundle2"""
     namespace = inpart.params['namespace']
     r = pushkey.decodekeys(inpart.read())
     op.records.add('listkeys', (namespace, r))
 
 @parthandler('pushkey', ('namespace', 'key', 'old', 'new'))
 def handlepushkey(op, inpart):
     """process a pushkey request"""
     dec = pushkey.decode
     namespace = dec(inpart.params['namespace'])
     key = dec(inpart.params['key'])
     old = dec(inpart.params['old'])
     new = dec(inpart.params['new'])
     # Grab the transaction to ensure that we have the lock before performing the
     # pushkey.
     if op.ui.configbool('experimental', 'bundle2lazylocking'):
         op.gettransaction()
     ret = op.repo.pushkey(namespace, key, old, new)
     record = {'namespace': namespace,
               'key': key,
               'old': old,
               'new': new}
     op.records.add('pushkey', record)
     if op.reply is not None:
         rpart = op.reply.newpart('reply:pushkey')
         rpart.addparam('in-reply-to', str(inpart.id), mandatory=False)
         rpart.addparam('return', '%i' % ret, mandatory=False)
     if inpart.mandatory and not ret:
         kwargs = {}
         for key in ('namespace', 'key', 'new', 'old', 'ret'):
             if key in inpart.params:
                 kwargs[key] = inpart.params[key]
         raise error.PushkeyFailed(partid=str(inpart.id), **kwargs)
 
 @parthandler('reply:pushkey', ('return', 'in-reply-to'))
 def handlepushkeyreply(op, inpart):
     """retrieve the result of a pushkey request"""
     ret = int(inpart.params['return'])
     partid = int(inpart.params['in-reply-to'])
     op.records.add('pushkey', {'return': ret}, partid)
 
 @parthandler('obsmarkers')
 def handleobsmarker(op, inpart):
     """add a stream of obsmarkers to the repo"""
     tr = op.gettransaction()
     markerdata = inpart.read()
     if op.ui.config('experimental', 'obsmarkers-exchange-debug', False):
         op.ui.write(('obsmarker-exchange: %i bytes received\n')
                     % len(markerdata))
     # The mergemarkers call will crash if marker creation is not enabled.
     # we want to avoid this if the part is advisory.
     if not inpart.mandatory and op.repo.obsstore.readonly:
         op.repo.ui.debug('ignoring obsolescence markers, feature not enabled')
         return
     new = op.repo.obsstore.mergemarkers(tr, markerdata)
     if new:
         op.repo.ui.status(_('%i new obsolescence markers\n') % new)
     op.records.add('obsmarkers', {'new': new})
     if op.reply is not None:
         rpart = op.reply.newpart('reply:obsmarkers')
         rpart.addparam('in-reply-to', str(inpart.id), mandatory=False)
         rpart.addparam('new', '%i' % new, mandatory=False)
 
 
 @parthandler('reply:obsmarkers', ('new', 'in-reply-to'))
 def handleobsmarkerreply(op, inpart):
     """retrieve the result of a pushkey request"""
     ret = int(inpart.params['new'])
     partid = int(inpart.params['in-reply-to'])
     op.records.add('obsmarkers', {'new': ret}, partid)
 
 @parthandler('hgtagsfnodes')
 def handlehgtagsfnodes(op, inpart):
     """Applies .hgtags fnodes cache entries to the local repo.
 
     Payload is pairs of 20 byte changeset nodes and filenodes.
     """
     # Grab the transaction so we ensure that we have the lock at this point.
     if op.ui.configbool('experimental', 'bundle2lazylocking'):
         op.gettransaction()
     cache = tags.hgtagsfnodescache(op.repo.unfiltered())
 
     count = 0
     while True:
         node = inpart.read(20)
         fnode = inpart.read(20)
         if len(node) < 20 or len(fnode) < 20:
             op.ui.debug('ignoring incomplete received .hgtags fnodes data\n')
             break
         cache.setfnode(node, fnode)
         count += 1
 
     cache.write()
     op.ui.debug('applied %i hgtags fnodes cache entries\n' % count)

mercurial/changegroup.py

@@ -1,1063 +1,1065 b''
 # changegroup.py - Mercurial changegroup manipulation functions
 #
 #  Copyright 2006 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 os
 import struct
 import tempfile
 import weakref
 
 from .i18n import _
 from .node import (
     hex,
     nullid,
     nullrev,
     short,
 )
 
 from . import (
     branchmap,
     dagutil,
     discovery,
     error,
     mdiff,
     phases,
     util,
 )
 
 _CHANGEGROUPV1_DELTA_HEADER = "20s20s20s20s"
 _CHANGEGROUPV2_DELTA_HEADER = "20s20s20s20s20s"
 _CHANGEGROUPV3_DELTA_HEADER = ">20s20s20s20s20sH"
 
 def readexactly(stream, n):
     '''read n bytes from stream.read and abort if less was available'''
     s = stream.read(n)
     if len(s) < n:
         raise error.Abort(_("stream ended unexpectedly"
                            " (got %d bytes, expected %d)")
                           % (len(s), n))
     return s
 
 def getchunk(stream):
     """return the next chunk from stream as a string"""
     d = readexactly(stream, 4)
     l = struct.unpack(">l", d)[0]
     if l <= 4:
         if l:
             raise error.Abort(_("invalid chunk length %d") % l)
         return ""
     return readexactly(stream, l - 4)
 
 def chunkheader(length):
     """return a changegroup chunk header (string)"""
     return struct.pack(">l", length + 4)
 
 def closechunk():
     """return a changegroup chunk header (string) for a zero-length chunk"""
     return struct.pack(">l", 0)
 
 def combineresults(results):
     """logic to combine 0 or more addchangegroup results into one"""
     changedheads = 0
     result = 1
     for ret in results:
         # If any changegroup result is 0, return 0
         if ret == 0:
             result = 0
             break
         if ret < -1:
             changedheads += ret + 1
         elif ret > 1:
             changedheads += ret - 1
     if changedheads > 0:
         result = 1 + changedheads
     elif changedheads < 0:
         result = -1 + changedheads
     return result
 
 def writechunks(ui, chunks, filename, vfs=None):
     """Write chunks to a file and return its filename.
 
     The stream is assumed to be a bundle file.
     Existing files will not be overwritten.
     If no filename is specified, a temporary file is created.
     """
     fh = None
     cleanup = None
     try:
         if filename:
             if vfs:
                 fh = vfs.open(filename, "wb")
             else:
                 fh = open(filename, "wb")
         else:
             fd, filename = tempfile.mkstemp(prefix="hg-bundle-", suffix=".hg")
             fh = os.fdopen(fd, "wb")
         cleanup = filename
         for c in chunks:
             fh.write(c)
         cleanup = None
         return filename
     finally:
         if fh is not None:
             fh.close()
         if cleanup is not None:
             if filename and vfs:
                 vfs.unlink(cleanup)
             else:
                 os.unlink(cleanup)
 
 class cg1unpacker(object):
     """Unpacker for cg1 changegroup streams.
 
     A changegroup unpacker handles the framing of the revision data in
     the wire format. Most consumers will want to use the apply()
     method to add the changes from the changegroup to a repository.
 
     If you're forwarding a changegroup unmodified to another consumer,
     use getchunks(), which returns an iterator of changegroup
     chunks. This is mostly useful for cases where you need to know the
     data stream has ended by observing the end of the changegroup.
 
     deltachunk() is useful only if you're applying delta data. Most
     consumers should prefer apply() instead.
 
     A few other public methods exist. Those are used only for
     bundlerepo and some debug commands - their use is discouraged.
     """
     deltaheader = _CHANGEGROUPV1_DELTA_HEADER
     deltaheadersize = struct.calcsize(deltaheader)
     version = '01'
     _grouplistcount = 1 # One list of files after the manifests
 
-    def __init__(self, fh, alg):
+    def __init__(self, fh, alg, extras=None):
         if alg == 'UN':
             alg = None # get more modern without breaking too much
         if not alg in util.decompressors:
             raise error.Abort(_('unknown stream compression type: %s')
                              % alg)
         if alg == 'BZ':
             alg = '_truncatedBZ'
         self._stream = util.decompressors[alg](fh)
         self._type = alg
+        self.extras = extras or {}
         self.callback = None
 
     # These methods (compressed, read, seek, tell) all appear to only
     # be used by bundlerepo, but it's a little hard to tell.
     def compressed(self):
         return self._type is not None
     def read(self, l):
         return self._stream.read(l)
     def seek(self, pos):
         return self._stream.seek(pos)
     def tell(self):
         return self._stream.tell()
     def close(self):
         return self._stream.close()
 
     def _chunklength(self):
         d = readexactly(self._stream, 4)
         l = struct.unpack(">l", d)[0]
         if l <= 4:
             if l:
                 raise error.Abort(_("invalid chunk length %d") % l)
             return 0
         if self.callback:
             self.callback()
         return l - 4
 
     def changelogheader(self):
         """v10 does not have a changelog header chunk"""
         return {}
 
     def manifestheader(self):
         """v10 does not have a manifest header chunk"""
         return {}
 
     def filelogheader(self):
         """return the header of the filelogs chunk, v10 only has the filename"""
         l = self._chunklength()
         if not l:
             return {}
         fname = readexactly(self._stream, l)
         return {'filename': fname}
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, cs = headertuple
         if prevnode is None:
             deltabase = p1
         else:
             deltabase = prevnode
         flags = 0
         return node, p1, p2, deltabase, cs, flags
 
     def deltachunk(self, prevnode):
         l = self._chunklength()
         if not l:
             return {}
         headerdata = readexactly(self._stream, self.deltaheadersize)
         header = struct.unpack(self.deltaheader, headerdata)
         delta = readexactly(self._stream, l - self.deltaheadersize)
         node, p1, p2, deltabase, cs, flags = self._deltaheader(header, prevnode)
         return {'node': node, 'p1': p1, 'p2': p2, 'cs': cs,
                 'deltabase': deltabase, 'delta': delta, 'flags': flags}
 
     def getchunks(self):
         """returns all the chunks contains in the bundle
 
         Used when you need to forward the binary stream to a file or another
         network API. To do so, it parse the changegroup data, otherwise it will
         block in case of sshrepo because it don't know the end of the stream.
         """
         # an empty chunkgroup is the end of the changegroup
         # a changegroup has at least 2 chunkgroups (changelog and manifest).
         # after that, changegroup versions 1 and 2 have a series of groups
         # with one group per file. changegroup 3 has a series of directory
         # manifests before the files.
         count = 0
         emptycount = 0
         while emptycount < self._grouplistcount:
             empty = True
             count += 1
             while True:
                 chunk = getchunk(self)
                 if not chunk:
                     if empty and count > 2:
                         emptycount += 1
                     break
                 empty = False
                 yield chunkheader(len(chunk))
                 pos = 0
                 while pos < len(chunk):
                     next = pos + 2**20
                     yield chunk[pos:next]
                     pos = next
             yield closechunk()
 
     def _unpackmanifests(self, repo, revmap, trp, prog, numchanges):
         # We know that we'll never have more manifests than we had
         # changesets.
         self.callback = prog(_('manifests'), numchanges)
         # no need to check for empty manifest group here:
         # if the result of the merge of 1 and 2 is the same in 3 and 4,
         # no new manifest will be created and the manifest group will
         # be empty during the pull
         self.manifestheader()
         repo.manifest.addgroup(self, revmap, trp)
         repo.ui.progress(_('manifests'), None)
         self.callback = None
 
     def apply(self, repo, srctype, url, emptyok=False,
               targetphase=phases.draft, expectedtotal=None):
         """Add the changegroup returned by source.read() to this repo.
         srctype is a string like 'push', 'pull', or 'unbundle'.  url is
         the URL of the repo where this changegroup is coming from.
 
         Return an integer summarizing the change to this repo:
         - nothing changed or no source: 0
         - more heads than before: 1+added heads (2..n)
         - fewer heads than before: -1-removed heads (-2..-n)
         - number of heads stays the same: 1
         """
         repo = repo.unfiltered()
         def csmap(x):
             repo.ui.debug("add changeset %s\n" % short(x))
             return len(cl)
 
         def revmap(x):
             return cl.rev(x)
 
         changesets = files = revisions = 0
 
         try:
             with repo.transaction("\n".join([srctype,
                                              util.hidepassword(url)])) as tr:
                 # The transaction could have been created before and already
                 # carries source information. In this case we use the top
                 # level data. We overwrite the argument because we need to use
                 # the top level value (if they exist) in this function.
                 srctype = tr.hookargs.setdefault('source', srctype)
                 url = tr.hookargs.setdefault('url', url)
                 repo.hook('prechangegroup', throw=True, **tr.hookargs)
 
                 # write changelog data to temp files so concurrent readers
                 # will not see an inconsistent view
                 cl = repo.changelog
                 cl.delayupdate(tr)
                 oldheads = cl.heads()
 
                 trp = weakref.proxy(tr)
                 # pull off the changeset group
                 repo.ui.status(_("adding changesets\n"))
                 clstart = len(cl)
                 class prog(object):
                     def __init__(self, step, total):
                         self._step = step
                         self._total = total
                         self._count = 1
                     def __call__(self):
                         repo.ui.progress(self._step, self._count,
                                          unit=_('chunks'), total=self._total)
                         self._count += 1
                 self.callback = prog(_('changesets'), expectedtotal)
 
                 efiles = set()
                 def onchangelog(cl, node):
                     efiles.update(cl.readfiles(node))
 
                 self.changelogheader()
                 srccontent = cl.addgroup(self, csmap, trp,
                                          addrevisioncb=onchangelog)
                 efiles = len(efiles)
 
                 if not (srccontent or emptyok):
                     raise error.Abort(_("received changelog group is empty"))
                 clend = len(cl)
                 changesets = clend - clstart
                 repo.ui.progress(_('changesets'), None)
                 self.callback = None
 
                 # pull off the manifest group
                 repo.ui.status(_("adding manifests\n"))
                 self._unpackmanifests(repo, revmap, trp, prog, changesets)
 
                 needfiles = {}
                 if repo.ui.configbool('server', 'validate', default=False):
                     # validate incoming csets have their manifests
                     for cset in xrange(clstart, clend):
                         mfnode = repo.changelog.read(
                             repo.changelog.node(cset))[0]
                         mfest = repo.manifest.readdelta(mfnode)
                         # store file nodes we must see
                         for f, n in mfest.iteritems():
                             needfiles.setdefault(f, set()).add(n)
 
                 # process the files
                 repo.ui.status(_("adding file changes\n"))
                 newrevs, newfiles = _addchangegroupfiles(
                     repo, self, revmap, trp, efiles, needfiles)
                 revisions += newrevs
                 files += newfiles
 
                 dh = 0
                 if oldheads:
                     heads = cl.heads()
                     dh = len(heads) - len(oldheads)
                     for h in heads:
                         if h not in oldheads and repo[h].closesbranch():
                             dh -= 1
                 htext = ""
                 if dh:
                     htext = _(" (%+d heads)") % dh
 
                 repo.ui.status(_("added %d changesets"
                                  " with %d changes to %d files%s\n")
                                  % (changesets, revisions, files, htext))
                 repo.invalidatevolatilesets()
 
                 if changesets > 0:
                     if 'node' not in tr.hookargs:
                         tr.hookargs['node'] = hex(cl.node(clstart))
                         tr.hookargs['node_last'] = hex(cl.node(clend - 1))
                         hookargs = dict(tr.hookargs)
                     else:
                         hookargs = dict(tr.hookargs)
                         hookargs['node'] = hex(cl.node(clstart))
                         hookargs['node_last'] = hex(cl.node(clend - 1))
                     repo.hook('pretxnchangegroup', throw=True, **hookargs)
 
                 added = [cl.node(r) for r in xrange(clstart, clend)]
                 publishing = repo.publishing()
                 if srctype in ('push', 'serve'):
                     # Old servers can not push the boundary themselves.
                     # New servers won't push the boundary if changeset already
                     # exists locally as secret
                     #
                     # We should not use added here but the list of all change in
                     # the bundle
                     if publishing:
                         phases.advanceboundary(repo, tr, phases.public,
                                                srccontent)
                     else:
                         # Those changesets have been pushed from the
                         # outside, their phases are going to be pushed
                         # alongside. Therefor `targetphase` is
                         # ignored.
                         phases.advanceboundary(repo, tr, phases.draft,
                                                srccontent)
                         phases.retractboundary(repo, tr, phases.draft, added)
                 elif srctype != 'strip':
                     # publishing only alter behavior during push
                     #
                     # strip should not touch boundary at all
                     phases.retractboundary(repo, tr, targetphase, added)
 
                 if changesets > 0:
                     if srctype != 'strip':
                         # During strip, branchcache is invalid but
                         # coming call to `destroyed` will repair it.
                         # In other case we can safely update cache on
                         # disk.
                         branchmap.updatecache(repo.filtered('served'))
 
                     def runhooks():
                         # These hooks run when the lock releases, not when the
                         # transaction closes. So it's possible for the changelog
                         # to have changed since we last saw it.
                         if clstart >= len(repo):
                             return
 
                         # forcefully update the on-disk branch cache
                         repo.ui.debug("updating the branch cache\n")
                         repo.hook("changegroup", **hookargs)
 
                         for n in added:
                             args = hookargs.copy()
                             args['node'] = hex(n)
                             del args['node_last']
                             repo.hook("incoming", **args)
 
                         newheads = [h for h in repo.heads()
                                     if h not in oldheads]
                         repo.ui.log("incoming",
                                     "%s incoming changes - new heads: %s\n",
                                     len(added),
                                     ', '.join([hex(c[:6]) for c in newheads]))
 
                     tr.addpostclose('changegroup-runhooks-%020i' % clstart,
                                     lambda tr: repo._afterlock(runhooks))
         finally:
             repo.ui.flush()
         # never return 0 here:
         if dh < 0:
             return dh - 1
         else:
             return dh + 1
 
 class cg2unpacker(cg1unpacker):
     """Unpacker for cg2 streams.
 
     cg2 streams add support for generaldelta, so the delta header
     format is slightly different. All other features about the data
     remain the same.
     """
     deltaheader = _CHANGEGROUPV2_DELTA_HEADER
     deltaheadersize = struct.calcsize(deltaheader)
     version = '02'
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs = headertuple
         flags = 0
         return node, p1, p2, deltabase, cs, flags
 
 class cg3unpacker(cg2unpacker):
     """Unpacker for cg3 streams.
 
     cg3 streams add support for exchanging treemanifests and revlog
     flags. It adds the revlog flags to the delta header and an empty chunk
     separating manifests and files.
     """
     deltaheader = _CHANGEGROUPV3_DELTA_HEADER
     deltaheadersize = struct.calcsize(deltaheader)
     version = '03'
     _grouplistcount = 2 # One list of manifests and one list of files
 
     def _deltaheader(self, headertuple, prevnode):
         node, p1, p2, deltabase, cs, flags = headertuple
         return node, p1, p2, deltabase, cs, flags
 
     def _unpackmanifests(self, repo, revmap, trp, prog, numchanges):
         super(cg3unpacker, self)._unpackmanifests(repo, revmap, trp, prog,
                                                   numchanges)
         while True:
             chunkdata = self.filelogheader()
             if not chunkdata:
                 break
             # If we get here, there are directory manifests in the changegroup
             d = chunkdata["filename"]
             repo.ui.debug("adding %s revisions\n" % d)
             dirlog = repo.manifest.dirlog(d)
             if not dirlog.addgroup(self, revmap, trp):
                 raise error.Abort(_("received dir revlog group is empty"))
 
 class headerlessfixup(object):
     def __init__(self, fh, h):
         self._h = h
         self._fh = fh
     def read(self, n):
         if self._h:
             d, self._h = self._h[:n], self._h[n:]
             if len(d) < n:
                 d += readexactly(self._fh, n - len(d))
             return d
         return readexactly(self._fh, n)
 
 class cg1packer(object):
     deltaheader = _CHANGEGROUPV1_DELTA_HEADER
     version = '01'
     def __init__(self, repo, bundlecaps=None):
         """Given a source repo, construct a bundler.
 
         bundlecaps is optional and can be used to specify the set of
         capabilities which can be used to build the bundle.
         """
         # Set of capabilities we can use to build the bundle.
         if bundlecaps is None:
             bundlecaps = set()
         self._bundlecaps = bundlecaps
         # experimental config: bundle.reorder
         reorder = repo.ui.config('bundle', 'reorder', 'auto')
         if reorder == 'auto':
             reorder = None
         else:
             reorder = util.parsebool(reorder)
         self._repo = repo
         self._reorder = reorder
         self._progress = repo.ui.progress
         if self._repo.ui.verbose and not self._repo.ui.debugflag:
             self._verbosenote = self._repo.ui.note
         else:
             self._verbosenote = lambda s: None
 
     def close(self):
         return closechunk()
 
     def fileheader(self, fname):
         return chunkheader(len(fname)) + fname
 
     # Extracted both for clarity and for overriding in extensions.
     def _sortgroup(self, revlog, nodelist, lookup):
         """Sort nodes for change group and turn them into revnums."""
         # for generaldelta revlogs, we linearize the revs; this will both be
         # much quicker and generate a much smaller bundle
         if (revlog._generaldelta and self._reorder is None) or self._reorder:
             dag = dagutil.revlogdag(revlog)
             return dag.linearize(set(revlog.rev(n) for n in nodelist))
         else:
             return sorted([revlog.rev(n) for n in nodelist])
 
     def group(self, nodelist, revlog, lookup, units=None):
         """Calculate a delta group, yielding a sequence of changegroup chunks
         (strings).
 
         Given a list of changeset revs, return a set of deltas and
         metadata corresponding to nodes. The first delta is
         first parent(nodelist[0]) -> nodelist[0], the receiver is
         guaranteed to have this parent as it has all history before
         these changesets. In the case firstparent is nullrev the
         changegroup starts with a full revision.
 
         If units is not None, progress detail will be generated, units specifies
         the type of revlog that is touched (changelog, manifest, etc.).
         """
         # if we don't have any revisions touched by these changesets, bail
         if len(nodelist) == 0:
             yield self.close()
             return
 
         revs = self._sortgroup(revlog, nodelist, lookup)
 
         # add the parent of the first rev
         p = revlog.parentrevs(revs[0])[0]
         revs.insert(0, p)
 
         # build deltas
         total = len(revs) - 1
         msgbundling = _('bundling')
         for r in xrange(len(revs) - 1):
             if units is not None:
                 self._progress(msgbundling, r + 1, unit=units, total=total)
             prev, curr = revs[r], revs[r + 1]
             linknode = lookup(revlog.node(curr))
             for c in self.revchunk(revlog, curr, prev, linknode):
                 yield c
 
         if units is not None:
             self._progress(msgbundling, None)
         yield self.close()
 
     # filter any nodes that claim to be part of the known set
     def prune(self, revlog, missing, commonrevs):
         rr, rl = revlog.rev, revlog.linkrev
         return [n for n in missing if rl(rr(n)) not in commonrevs]
 
     def _packmanifests(self, dir, mfnodes, lookuplinknode):
         """Pack flat manifests into a changegroup stream."""
         assert not dir
         for chunk in self.group(mfnodes, self._repo.manifest,
                                 lookuplinknode, units=_('manifests')):
             yield chunk
 
     def _manifestsdone(self):
         return ''
 
     def generate(self, commonrevs, clnodes, fastpathlinkrev, source):
         '''yield a sequence of changegroup chunks (strings)'''
         repo = self._repo
         cl = repo.changelog
 
         clrevorder = {}
         mfs = {} # needed manifests
         fnodes = {} # needed file nodes
         changedfiles = set()
 
         # Callback for the changelog, used to collect changed files and manifest
         # nodes.
         # Returns the linkrev node (identity in the changelog case).
         def lookupcl(x):
             c = cl.read(x)
             clrevorder[x] = len(clrevorder)
             n = c[0]
             # record the first changeset introducing this manifest version
             mfs.setdefault(n, x)
             # Record a complete list of potentially-changed files in
             # this manifest.
             changedfiles.update(c[3])
             return x
 
         self._verbosenote(_('uncompressed size of bundle content:\n'))
         size = 0
         for chunk in self.group(clnodes, cl, lookupcl, units=_('changesets')):
             size += len(chunk)
             yield chunk
         self._verbosenote(_('%8.i (changelog)\n') % size)
 
         # We need to make sure that the linkrev in the changegroup refers to
         # the first changeset that introduced the manifest or file revision.
         # The fastpath is usually safer than the slowpath, because the filelogs
         # are walked in revlog order.
         #
         # When taking the slowpath with reorder=None and the manifest revlog
         # uses generaldelta, the manifest may be walked in the "wrong" order.
         # Without 'clrevorder', we would get an incorrect linkrev (see fix in
         # cc0ff93d0c0c).
         #
         # When taking the fastpath, we are only vulnerable to reordering
         # of the changelog itself. The changelog never uses generaldelta, so
         # it is only reordered when reorder=True. To handle this case, we
         # simply take the slowpath, which already has the 'clrevorder' logic.
         # This was also fixed in cc0ff93d0c0c.
         fastpathlinkrev = fastpathlinkrev and not self._reorder
         # Treemanifests don't work correctly with fastpathlinkrev
         # either, because we don't discover which directory nodes to
         # send along with files. This could probably be fixed.
         fastpathlinkrev = fastpathlinkrev and (
             'treemanifest' not in repo.requirements)
 
         for chunk in self.generatemanifests(commonrevs, clrevorder,
                 fastpathlinkrev, mfs, fnodes):
             yield chunk
         mfs.clear()
         clrevs = set(cl.rev(x) for x in clnodes)
 
         if not fastpathlinkrev:
             def linknodes(unused, fname):
                 return fnodes.get(fname, {})
         else:
             cln = cl.node
             def linknodes(filerevlog, fname):
                 llr = filerevlog.linkrev
                 fln = filerevlog.node
                 revs = ((r, llr(r)) for r in filerevlog)
                 return dict((fln(r), cln(lr)) for r, lr in revs if lr in clrevs)
 
         for chunk in self.generatefiles(changedfiles, linknodes, commonrevs,
                                         source):
             yield chunk
 
         yield self.close()
 
         if clnodes:
             repo.hook('outgoing', node=hex(clnodes[0]), source=source)
 
     def generatemanifests(self, commonrevs, clrevorder, fastpathlinkrev, mfs,
                           fnodes):
         repo = self._repo
         dirlog = repo.manifest.dirlog
         tmfnodes = {'': mfs}
 
         # Callback for the manifest, used to collect linkrevs for filelog
         # revisions.
         # Returns the linkrev node (collected in lookupcl).
         def makelookupmflinknode(dir):
             if fastpathlinkrev:
                 assert not dir
                 return mfs.__getitem__
 
             def lookupmflinknode(x):
                 """Callback for looking up the linknode for manifests.
 
                 Returns the linkrev node for the specified manifest.
 
                 SIDE EFFECT:
 
                 1) fclnodes gets populated with the list of relevant
                    file nodes if we're not using fastpathlinkrev
                 2) When treemanifests are in use, collects treemanifest nodes
                    to send
 
                 Note that this means manifests must be completely sent to
                 the client before you can trust the list of files and
                 treemanifests to send.
                 """
                 clnode = tmfnodes[dir][x]
                 mdata = dirlog(dir).readshallowfast(x)
                 for p, n, fl in mdata.iterentries():
                     if fl == 't': # subdirectory manifest
                         subdir = dir + p + '/'
                         tmfclnodes = tmfnodes.setdefault(subdir, {})
                         tmfclnode = tmfclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[tmfclnode]:
                             tmfclnodes[n] = clnode
                     else:
                         f = dir + p
                         fclnodes = fnodes.setdefault(f, {})
                         fclnode = fclnodes.setdefault(n, clnode)
                         if clrevorder[clnode] < clrevorder[fclnode]:
                             fclnodes[n] = clnode
                 return clnode
             return lookupmflinknode
 
         size = 0
         while tmfnodes:
             dir = min(tmfnodes)
             nodes = tmfnodes[dir]
             prunednodes = self.prune(dirlog(dir), nodes, commonrevs)
             if not dir or prunednodes:
                 for x in self._packmanifests(dir, prunednodes,
                                              makelookupmflinknode(dir)):
                     size += len(x)
                     yield x
             del tmfnodes[dir]
         self._verbosenote(_('%8.i (manifests)\n') % size)
         yield self._manifestsdone()
 
     # The 'source' parameter is useful for extensions
     def generatefiles(self, changedfiles, linknodes, commonrevs, source):
         repo = self._repo
         progress = self._progress
         msgbundling = _('bundling')
 
         total = len(changedfiles)
         # for progress output
         msgfiles = _('files')
         for i, fname in enumerate(sorted(changedfiles)):
             filerevlog = repo.file(fname)
             if not filerevlog:
                 raise error.Abort(_("empty or missing revlog for %s") % fname)
 
             linkrevnodes = linknodes(filerevlog, fname)
             # Lookup for filenodes, we collected the linkrev nodes above in the
             # fastpath case and with lookupmf in the slowpath case.
             def lookupfilelog(x):
                 return linkrevnodes[x]
 
             filenodes = self.prune(filerevlog, linkrevnodes, commonrevs)
             if filenodes:
                 progress(msgbundling, i + 1, item=fname, unit=msgfiles,
                          total=total)
                 h = self.fileheader(fname)
                 size = len(h)
                 yield h
                 for chunk in self.group(filenodes, filerevlog, lookupfilelog):
                     size += len(chunk)
                     yield chunk
                 self._verbosenote(_('%8.i  %s\n') % (size, fname))
         progress(msgbundling, None)
 
     def deltaparent(self, revlog, rev, p1, p2, prev):
         return prev
 
     def revchunk(self, revlog, rev, prev, linknode):
         node = revlog.node(rev)
         p1, p2 = revlog.parentrevs(rev)
         base = self.deltaparent(revlog, rev, p1, p2, prev)
 
         prefix = ''
         if revlog.iscensored(base) or revlog.iscensored(rev):
             try:
                 delta = revlog.revision(node)
             except error.CensoredNodeError as e:
                 delta = e.tombstone
             if base == nullrev:
                 prefix = mdiff.trivialdiffheader(len(delta))
             else:
                 baselen = revlog.rawsize(base)
                 prefix = mdiff.replacediffheader(baselen, len(delta))
         elif base == nullrev:
             delta = revlog.revision(node)
             prefix = mdiff.trivialdiffheader(len(delta))
         else:
             delta = revlog.revdiff(base, rev)
         p1n, p2n = revlog.parents(node)
         basenode = revlog.node(base)
         flags = revlog.flags(rev)
         meta = self.builddeltaheader(node, p1n, p2n, basenode, linknode, flags)
         meta += prefix
         l = len(meta) + len(delta)
         yield chunkheader(l)
         yield meta
         yield delta
     def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
         # do nothing with basenode, it is implicitly the previous one in HG10
         # do nothing with flags, it is implicitly 0 for cg1 and cg2
         return struct.pack(self.deltaheader, node, p1n, p2n, linknode)
 
 class cg2packer(cg1packer):
     version = '02'
     deltaheader = _CHANGEGROUPV2_DELTA_HEADER
 
     def __init__(self, repo, bundlecaps=None):
         super(cg2packer, self).__init__(repo, bundlecaps)
         if self._reorder is None:
             # Since generaldelta is directly supported by cg2, reordering
             # generally doesn't help, so we disable it by default (treating
             # bundle.reorder=auto just like bundle.reorder=False).
             self._reorder = False
 
     def deltaparent(self, revlog, rev, p1, p2, prev):
         dp = revlog.deltaparent(rev)
         # avoid storing full revisions; pick prev in those cases
         # also pick prev when we can't be sure remote has dp
         if dp == nullrev or (dp != p1 and dp != p2 and dp != prev):
             return prev
         return dp
 
     def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
         # Do nothing with flags, it is implicitly 0 in cg1 and cg2
         return struct.pack(self.deltaheader, node, p1n, p2n, basenode, linknode)
 
 class cg3packer(cg2packer):
     version = '03'
     deltaheader = _CHANGEGROUPV3_DELTA_HEADER
 
     def _packmanifests(self, dir, mfnodes, lookuplinknode):
         if dir:
             yield self.fileheader(dir)
         for chunk in self.group(mfnodes, self._repo.manifest.dirlog(dir),
                                 lookuplinknode, units=_('manifests')):
             yield chunk
 
     def _manifestsdone(self):
         return self.close()
 
     def builddeltaheader(self, node, p1n, p2n, basenode, linknode, flags):
         return struct.pack(
             self.deltaheader, node, p1n, p2n, basenode, linknode, flags)
 
 _packermap = {'01': (cg1packer, cg1unpacker),
              # cg2 adds support for exchanging generaldelta
              '02': (cg2packer, cg2unpacker),
              # cg3 adds support for exchanging revlog flags and treemanifests
              '03': (cg3packer, cg3unpacker),
 }
 
 def allsupportedversions(ui):
     versions = set(_packermap.keys())
     versions.discard('03')
     if (ui.configbool('experimental', 'changegroup3') or
         ui.configbool('experimental', 'treemanifest')):
         versions.add('03')
     return versions
 
 # Changegroup versions that can be applied to the repo
 def supportedincomingversions(repo):
     versions = allsupportedversions(repo.ui)
     if 'treemanifest' in repo.requirements:
         versions.add('03')
     return versions
 
 # Changegroup versions that can be created from the repo
 def supportedoutgoingversions(repo):
     versions = allsupportedversions(repo.ui)
     if 'treemanifest' in repo.requirements:
         # Versions 01 and 02 support only flat manifests and it's just too
         # expensive to convert between the flat manifest and tree manifest on
         # the fly. Since tree manifests are hashed differently, all of history
         # would have to be converted. Instead, we simply don't even pretend to
         # support versions 01 and 02.
         versions.discard('01')
         versions.discard('02')
         versions.add('03')
     return versions
 
 def safeversion(repo):
     # Finds the smallest version that it's safe to assume clients of the repo
     # will support. For example, all hg versions that support generaldelta also
     # support changegroup 02.
     versions = supportedoutgoingversions(repo)
     if 'generaldelta' in repo.requirements:
         versions.discard('01')
     assert versions
     return min(versions)
 
 def getbundler(version, repo, bundlecaps=None):
     assert version in supportedoutgoingversions(repo)
     return _packermap[version][0](repo, bundlecaps)
 
-def getunbundler(version, fh, alg):
-    return _packermap[version][1](fh, alg)
+def getunbundler(version, fh, alg, extras=None):
+    return _packermap[version][1](fh, alg, extras=extras)
 
 def _changegroupinfo(repo, nodes, source):
     if repo.ui.verbose or source == 'bundle':
         repo.ui.status(_("%d changesets found\n") % len(nodes))
     if repo.ui.debugflag:
         repo.ui.debug("list of changesets:\n")
         for node in nodes:
             repo.ui.debug("%s\n" % hex(node))
 
 def getsubsetraw(repo, outgoing, bundler, source, fastpath=False):
     repo = repo.unfiltered()
     commonrevs = outgoing.common
     csets = outgoing.missing
     heads = outgoing.missingheads
     # We go through the fast path if we get told to, or if all (unfiltered
     # heads have been requested (since we then know there all linkrevs will
     # be pulled by the client).
     heads.sort()
     fastpathlinkrev = fastpath or (
             repo.filtername is None and heads == sorted(repo.heads()))
 
     repo.hook('preoutgoing', throw=True, source=source)
     _changegroupinfo(repo, csets, source)
     return bundler.generate(commonrevs, csets, fastpathlinkrev, source)
 
 def getsubset(repo, outgoing, bundler, source, fastpath=False):
     gengroup = getsubsetraw(repo, outgoing, bundler, source, fastpath)
-    return getunbundler(bundler.version, util.chunkbuffer(gengroup), None)
+    return getunbundler(bundler.version, util.chunkbuffer(gengroup), None,
+                        {'clcount': len(outgoing.missing)})
 
 def changegroupsubset(repo, roots, heads, source, version='01'):
     """Compute a changegroup consisting of all the nodes that are
     descendants of any of the roots and ancestors of any of the heads.
     Return a chunkbuffer object whose read() method will return
     successive changegroup chunks.
 
     It is fairly complex as determining which filenodes and which
     manifest nodes need to be included for the changeset to be complete
     is non-trivial.
 
     Another wrinkle is doing the reverse, figuring out which changeset in
     the changegroup a particular filenode or manifestnode belongs to.
     """
     cl = repo.changelog
     if not roots:
         roots = [nullid]
     discbases = []
     for n in roots:
         discbases.extend([p for p in cl.parents(n) if p != nullid])
     # TODO: remove call to nodesbetween.
     csets, roots, heads = cl.nodesbetween(roots, heads)
     included = set(csets)
     discbases = [n for n in discbases if n not in included]
     outgoing = discovery.outgoing(cl, discbases, heads)
     bundler = getbundler(version, repo)
     return getsubset(repo, outgoing, bundler, source)
 
 def getlocalchangegroupraw(repo, source, outgoing, bundlecaps=None,
                            version='01'):
     """Like getbundle, but taking a discovery.outgoing as an argument.
 
     This is only implemented for local repos and reuses potentially
     precomputed sets in outgoing. Returns a raw changegroup generator."""
     if not outgoing.missing:
         return None
     bundler = getbundler(version, repo, bundlecaps)
     return getsubsetraw(repo, outgoing, bundler, source)
 
 def getlocalchangegroup(repo, source, outgoing, bundlecaps=None,
                         version='01'):
     """Like getbundle, but taking a discovery.outgoing as an argument.
 
     This is only implemented for local repos and reuses potentially
     precomputed sets in outgoing."""
     if not outgoing.missing:
         return None
     bundler = getbundler(version, repo, bundlecaps)
     return getsubset(repo, outgoing, bundler, source)
 
 def computeoutgoing(repo, heads, common):
     """Computes which revs are outgoing given a set of common
     and a set of heads.
 
     This is a separate function so extensions can have access to
     the logic.
 
     Returns a discovery.outgoing object.
     """
     cl = repo.changelog
     if common:
         hasnode = cl.hasnode
         common = [n for n in common if hasnode(n)]
     else:
         common = [nullid]
     if not heads:
         heads = cl.heads()
     return discovery.outgoing(cl, common, heads)
 
 def getchangegroup(repo, source, heads=None, common=None, bundlecaps=None,
                    version='01'):
     """Like changegroupsubset, but returns the set difference between the
     ancestors of heads and the ancestors common.
 
     If heads is None, use the local heads. If common is None, use [nullid].
 
     The nodes in common might not all be known locally due to the way the
     current discovery protocol works.
     """
     outgoing = computeoutgoing(repo, heads, common)
     return getlocalchangegroup(repo, source, outgoing, bundlecaps=bundlecaps,
                                version=version)
 
 def changegroup(repo, basenodes, source):
     # to avoid a race we use changegroupsubset() (issue1320)
     return changegroupsubset(repo, basenodes, repo.heads(), source)
 
 def _addchangegroupfiles(repo, source, revmap, trp, expectedfiles, needfiles):
     revisions = 0
     files = 0
     while True:
         chunkdata = source.filelogheader()
         if not chunkdata:
             break
         files += 1
         f = chunkdata["filename"]
         repo.ui.debug("adding %s revisions\n" % f)
         repo.ui.progress(_('files'), files, unit=_('files'),
                          total=expectedfiles)
         fl = repo.file(f)
         o = len(fl)
         try:
             if not fl.addgroup(source, revmap, trp):
                 raise error.Abort(_("received file revlog group is empty"))
         except error.CensoredBaseError as e:
             raise error.Abort(_("received delta base is censored: %s") % e)
         revisions += len(fl) - o
         if f in needfiles:
             needs = needfiles[f]
             for new in xrange(o, len(fl)):
                 n = fl.node(new)
                 if n in needs:
                     needs.remove(n)
                 else:
                     raise error.Abort(
                         _("received spurious file revlog entry"))
             if not needs:
                 del needfiles[f]
     repo.ui.progress(_('files'), None)
 
     for f, needs in needfiles.iteritems():
         fl = repo.file(f)
         for n in needs:
             try:
                 fl.rev(n)
             except error.LookupError:
                 raise error.Abort(
                     _('missing file data for %s:%s - run hg verify') %
                     (f, hex(n)))
 
     return revisions, files

tests/test-bundle-type.t

@@ -1,128 +1,128 b''
 
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usegeneraldelta=yes
   > EOF
 
 bundle w/o type option
 
   $ hg init t1
   $ hg init t2
   $ cd t1
   $ echo blablablablabla > file.txt
   $ hg ci -Ama
   adding file.txt
   $ hg log | grep summary
   summary:     a
   $ hg bundle ../b1 ../t2
   searching for changes
   1 changesets found
 
   $ cd ../t2
   $ hg pull ../b1
   pulling from ../b1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg log | grep summary
   summary:     a
   $ cd ..
 
 test bundle types
 
   $ for t in "None" "bzip2" "gzip" "none-v2" "v2" "v1" "gzip-v1"; do
   >   echo % test bundle type $t
   >   hg init t$t
   >   cd t1
   >   hg bundle -t $t ../b$t ../t$t
   >   f -q -B6 -D ../b$t; echo
   >   cd ../t$t
   >   hg debugbundle ../b$t
   >   hg debugbundle --spec ../b$t
   >   echo
   >   cd ..
   > done
   % test bundle type None
   searching for changes
   1 changesets found
   HG20\x00\x00 (esc)
   Stream params: {}
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   none-v2
   
   % test bundle type bzip2
   searching for changes
   1 changesets found
   HG20\x00\x00 (esc)
   Stream params: sortdict([('Compression', 'BZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   bzip2-v2
   
   % test bundle type gzip
   searching for changes
   1 changesets found
   HG20\x00\x00 (esc)
   Stream params: sortdict([('Compression', 'GZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   gzip-v2
   
   % test bundle type none-v2
   searching for changes
   1 changesets found
   HG20\x00\x00 (esc)
   Stream params: {}
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   none-v2
   
   % test bundle type v2
   searching for changes
   1 changesets found
   HG20\x00\x00 (esc)
   Stream params: sortdict([('Compression', 'BZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   bzip2-v2
   
   % test bundle type v1
   searching for changes
   1 changesets found
   HG10BZ
   c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   bzip2-v1
   
   % test bundle type gzip-v1
   searching for changes
   1 changesets found
   HG10GZ
   c35a0f9217e65d1fdb90c936ffa7dbe679f83ddf
   gzip-v1
   
 
 test garbage file
 
   $ echo garbage > bgarbage
   $ hg init tgarbage
   $ cd tgarbage
   $ hg pull ../bgarbage
   pulling from ../bgarbage
   abort: ../bgarbage: not a Mercurial bundle
   [255]
   $ cd ..
 
 test invalid bundle type
 
   $ cd t1
   $ hg bundle -a -t garbage ../bgarbage
   abort: garbage is not a recognized bundle specification
   (see "hg help bundle" for supported values for --type)
   [255]
   $ cd ..

tests/test-bundle.t

@@ -1,809 +1,809 b''
 
   $ cat << EOF >> $HGRCPATH
   > [format]
   > usegeneraldelta=yes
   > EOF
 
 Setting up test
 
   $ 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 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 9 changesets, 7 total revisions
   $ cd ..
   $ hg init empty
 
 Bundle and phase
 
   $ hg -R test phase --force --secret 0
   $ hg -R test bundle phase.hg empty
   searching for changes
   no changes found (ignored 9 secret changesets)
   [1]
   $ hg -R test phase --draft -r 'head()'
 
 Bundle --all
 
   $ hg -R test bundle --all all.hg
   9 changesets found
 
 Bundle test to full.hg
 
   $ hg -R test bundle full.hg empty
   searching for changes
   9 changesets found
 
 Unbundle full.hg in test
 
   $ hg -R test unbundle full.hg
   adding changesets
   adding manifests
   adding file changes
   added 0 changesets with 0 changes to 4 files
   (run 'hg update' to get a working copy)
 
 Verify empty
 
   $ hg -R empty heads
   [1]
   $ hg -R empty verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   0 files, 0 changesets, 0 total revisions
 
 Pull full.hg into test (using --cwd)
 
   $ hg --cwd test pull ../full.hg
   pulling from ../full.hg
   searching for changes
   no changes found
 
 Verify that there are no leaked temporary files after pull (issue2797)
 
   $ ls test/.hg | grep .hg10un
   [1]
 
 Pull full.hg into empty (using --cwd)
 
   $ hg --cwd empty pull ../full.hg
   pulling from ../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Rollback empty
 
   $ hg -R empty rollback
   repository tip rolled back to revision -1 (undo pull)
 
 Pull full.hg into empty again (using --cwd)
 
   $ hg --cwd empty pull ../full.hg
   pulling from ../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Pull full.hg into test (using -R)
 
   $ hg -R test pull full.hg
   pulling from full.hg
   searching for changes
   no changes found
 
 Pull full.hg into empty (using -R)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   searching for changes
   no changes found
 
 Rollback empty
 
   $ hg -R empty rollback
   repository tip rolled back to revision -1 (undo pull)
 
 Pull full.hg into empty again (using -R)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Log -R full.hg in fresh empty
 
   $ rm -r empty
   $ hg init empty
   $ cd empty
   $ hg -R bundle://../full.hg log
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   changeset:   2:e38ba6f5b7e0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   1:34c2bf6b0626
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
 Make sure bundlerepo doesn't leak tempfiles (issue2491)
 
   $ ls .hg
   00changelog.i
   cache
   requires
   store
 
 Pull ../full.hg into empty (with hook)
 
   $ echo "[hooks]" >> .hg/hgrc
   $ echo "changegroup = printenv.py changegroup" >> .hg/hgrc
 
 doesn't work (yet ?)
 
 hg -R bundle://../full.hg verify
 
   $ hg pull bundle://../full.hg
   pulling from bundle:../full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   changegroup hook: HG_NODE=f9ee2f85a263049e9ae6d37a0e67e96194ffb735 HG_NODE_LAST=aa35859c02ea8bd48da5da68cd2740ac71afcbaf HG_SOURCE=pull HG_TXNID=TXN:* HG_URL=bundle:../full.hg (glob)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Rollback empty
 
   $ hg rollback
   repository tip rolled back to revision -1 (undo pull)
   $ cd ..
 
 Log -R bundle:empty+full.hg
 
   $ hg -R bundle:empty+full.hg log --template="{rev} "; echo ""
   8 7 6 5 4 3 2 1 0 
 
 Pull full.hg into empty again (using -R; with hook)
 
   $ hg -R empty pull full.hg
   pulling from full.hg
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   changegroup hook: HG_NODE=f9ee2f85a263049e9ae6d37a0e67e96194ffb735 HG_NODE_LAST=aa35859c02ea8bd48da5da68cd2740ac71afcbaf HG_SOURCE=pull HG_TXNID=TXN:* HG_URL=bundle:empty+full.hg (glob)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Cannot produce streaming clone bundles with "hg bundle"
 
   $ hg -R test bundle -t packed1 packed.hg
   abort: packed bundles cannot be produced by "hg bundle"
   (use 'hg debugcreatestreamclonebundle')
   [255]
 
 packed1 is produced properly
 
   $ hg -R test debugcreatestreamclonebundle packed.hg
   writing 2663 bytes for 6 files
   bundle requirements: generaldelta, revlogv1
 
   $ f -B 64 --size --sha1 --hexdump packed.hg
   packed.hg: size=2826, sha1=e139f97692a142b19cdcff64a69697d5307ce6d4
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 06 00 00 |HGS1UN..........|
   0010: 00 00 00 00 0a 67 00 16 67 65 6e 65 72 61 6c 64 |.....g..generald|
   0020: 65 6c 74 61 2c 72 65 76 6c 6f 67 76 31 00 64 61 |elta,revlogv1.da|
   0030: 74 61 2f 61 64 69 66 66 65 72 65 6e 74 66 69 6c |ta/adifferentfil|
 
   $ hg debugbundle --spec packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlogv1
 
 generaldelta requirement is listed in stream clone bundles
 
   $ hg --config format.generaldelta=true init testgd
   $ cd testgd
   $ touch foo
   $ hg -q commit -A -m initial
   $ cd ..
   $ hg -R testgd debugcreatestreamclonebundle packedgd.hg
   writing 301 bytes for 3 files
   bundle requirements: generaldelta, revlogv1
 
   $ f -B 64 --size --sha1 --hexdump packedgd.hg
   packedgd.hg: size=396, sha1=981f9e589799335304a5a9a44caa3623a48d2a9f
   0000: 48 47 53 31 55 4e 00 00 00 00 00 00 00 03 00 00 |HGS1UN..........|
   0010: 00 00 00 00 01 2d 00 16 67 65 6e 65 72 61 6c 64 |.....-..generald|
   0020: 65 6c 74 61 2c 72 65 76 6c 6f 67 76 31 00 64 61 |elta,revlogv1.da|
   0030: 74 61 2f 66 6f 6f 2e 69 00 36 34 0a 00 03 00 01 |ta/foo.i.64.....|
 
   $ hg debugbundle --spec packedgd.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlogv1
 
 Unpacking packed1 bundles with "hg unbundle" isn't allowed
 
   $ hg init packed
   $ hg -R packed unbundle packed.hg
   abort: packed bundles cannot be applied with "hg unbundle"
   (use "hg debugapplystreamclonebundle")
   [255]
 
 packed1 can be consumed from debug command
 
   $ hg -R packed debugapplystreamclonebundle packed.hg
   6 files to transfer, 2.60 KB of data
   transferred 2.60 KB in *.* seconds (* */sec) (glob)
 
 Does not work on non-empty repo
 
   $ hg -R packed debugapplystreamclonebundle packed.hg
   abort: cannot apply stream clone bundle on non-empty repo
   [255]
 
 Create partial clones
 
   $ rm -r empty
   $ hg init empty
   $ hg clone -r 3 test partial
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 1 files
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg clone partial partial2
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd partial
 
 Log -R full.hg in partial
 
   $ hg -R bundle://../full.hg log -T phases
   changeset:   8:aa35859c02ea
   tag:         tip
   phase:       draft
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   6:7373c1169842
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   5:1bb50a9436a7
   phase:       draft
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   4:095197eb4973
   phase:       draft
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   3:eebf5a27f8ca
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   changeset:   2:e38ba6f5b7e0
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   1:34c2bf6b0626
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   0:f9ee2f85a263
   phase:       public
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
 
 Incoming full.hg in partial
 
   $ hg incoming bundle://../full.hg
   comparing with bundle:../full.hg
   searching for changes
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
 
 Outgoing -R full.hg vs partial2 in partial
 
   $ hg -R bundle://../full.hg outgoing ../partial2
   comparing with ../partial2
   searching for changes
   changeset:   4:095197eb4973
   parent:      0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.1
   
   changeset:   5:1bb50a9436a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.2
   
   changeset:   6:7373c1169842
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
 
 Outgoing -R does-not-exist.hg vs partial2 in partial
 
   $ hg -R bundle://../does-not-exist.hg outgoing ../partial2
   abort: *../does-not-exist.hg* (glob)
   [255]
   $ cd ..
 
 hide outer repo
   $ hg init
 
 Direct clone from bundle (all-history)
 
   $ hg clone full.hg full-clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 7 changes to 4 files (+1 heads)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R full-clone heads
   changeset:   8:aa35859c02ea
   tag:         tip
   parent:      3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3m
   
   changeset:   7:a6a34bfa0076
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1.3m
   
   $ rm -r full-clone
 
 When cloning from a non-copiable repository into '', do not
 recurse infinitely (issue2528)
 
   $ hg clone full.hg ''
   abort: empty destination path is not valid
   [255]
 
 test for https://bz.mercurial-scm.org/216
 
 Unbundle incremental bundles into fresh empty in one go
 
   $ rm -r empty
   $ hg init empty
   $ hg -R test bundle --base null -r 0 ../0.hg
   1 changesets found
   $ hg -R test bundle --base 0    -r 1 ../1.hg
   1 changesets found
   $ hg -R empty unbundle -u ../0.hg ../1.hg
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 View full contents of the bundle
   $ hg -R test bundle --base null -r 3  ../partial.hg
   4 changesets found
   $ cd test
   $ hg -R ../../partial.hg log -r "bundle()"
   changeset:   0:f9ee2f85a263
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.0
   
   changeset:   1:34c2bf6b0626
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.1
   
   changeset:   2:e38ba6f5b7e0
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.2
   
   changeset:   3:eebf5a27f8ca
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0.3
   
   $ cd ..
 
 test for 540d1059c802
 
 test for 540d1059c802
 
   $ hg init orig
   $ cd orig
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
 
   $ hg clone . ../copy
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg tag foo
 
   $ cd ../copy
   $ echo >> foo
   $ hg ci -m 'change foo'
   $ hg bundle ../bundle.hg ../orig
   searching for changes
   1 changesets found
 
   $ cd ../orig
   $ hg incoming ../bundle.hg
   comparing with ../bundle.hg
   searching for changes
   changeset:   2:ed1b79f46b9a
   tag:         tip
   parent:      0:bbd179dfa0a7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change foo
   
   $ cd ..
 
 test bundle with # in the filename (issue2154):
 
   $ cp bundle.hg 'test#bundle.hg'
   $ cd orig
   $ hg incoming '../test#bundle.hg'
   comparing with ../test
   abort: unknown revision 'bundle.hg'!
   [255]
 
 note that percent encoding is not handled:
 
   $ hg incoming ../test%23bundle.hg
   abort: repository ../test%23bundle.hg not found!
   [255]
   $ cd ..
 
 test to bundle revisions on the newly created branch (issue3828):
 
   $ hg -q clone -U test test-clone
   $ cd test
 
   $ hg -q branch foo
   $ hg commit -m "create foo branch"
   $ hg -q outgoing ../test-clone
   9:b4f5acb1ee27
   $ hg -q bundle --branch foo foo.hg ../test-clone
   $ hg -R foo.hg -q log -r "bundle()"
   9:b4f5acb1ee27
 
   $ cd ..
 
 test for https://bz.mercurial-scm.org/1144
 
 test that verify bundle does not traceback
 
 partial history bundle, fails w/ unknown parent
 
   $ hg -R bundle.hg verify
   abort: 00changelog.i@bbd179dfa0a7: unknown parent!
   [255]
 
 full history bundle, refuses to verify non-local repo
 
   $ hg -R all.hg verify
   abort: cannot verify bundle or remote repos
   [255]
 
 but, regular verify must continue to work
 
   $ hg -R orig verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
 
 diff against bundle
 
   $ hg init b
   $ cd b
   $ hg -R ../all.hg diff -r tip
   diff -r aa35859c02ea anotherfile
   --- a/anotherfile	Thu Jan 01 00:00:00 1970 +0000
   +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,4 +0,0 @@
   -0
   -1
   -2
   -3
   $ cd ..
 
 bundle single branch
 
   $ hg init branchy
   $ cd branchy
   $ echo a >a
   $ echo x >x
   $ hg ci -Ama
   adding a
   adding x
   $ echo c >c
   $ echo xx >x
   $ hg ci -Amc
   adding c
   $ echo c1 >c1
   $ hg ci -Amc1
   adding c1
   $ hg up 0
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo b >b
   $ hg ci -Amb
   adding b
   created new head
   $ echo b1 >b1
   $ echo xx >x
   $ hg ci -Amb1
   adding b1
   $ hg clone -q -r2 . part
 
 == bundling via incoming
 
   $ hg in -R part --bundle incoming.hg --template "{node}\n" .
   comparing with .
   searching for changes
   1a38c1b849e8b70c756d2d80b0b9a3ac0b7ea11a
   057f4db07f61970e1c11e83be79e9d08adc4dc31
 
 == bundling
 
   $ hg bundle bundle.hg part --debug --config progress.debug=true
   query 1; heads
   searching for changes
   all remote heads known locally
   2 changesets found
   list of changesets:
   1a38c1b849e8b70c756d2d80b0b9a3ac0b7ea11a
   057f4db07f61970e1c11e83be79e9d08adc4dc31
   bundle2-output-bundle: "HG20", (1 params) 1 parts total
-  bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
+  bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   bundling: 1/2 changesets (50.00%)
   bundling: 2/2 changesets (100.00%)
   bundling: 1/2 manifests (50.00%)
   bundling: 2/2 manifests (100.00%)
   bundling: b 1/3 files (33.33%)
   bundling: b1 2/3 files (66.67%)
   bundling: x 3/3 files (100.00%)
 
 == Test for issue3441
 
   $ hg clone -q -r0 . part2
   $ hg -q -R part2 pull bundle.hg
   $ hg -R part2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   4 files, 3 changesets, 5 total revisions
 
 == Test bundling no commits
 
   $ hg bundle -r 'public()' no-output.hg
   abort: no commits to bundle
   [255]
 
   $ cd ..
 
 When user merges to the revision existing only in the bundle,
 it should show warning that second parent of the working
 directory does not exist
 
   $ hg init update2bundled
   $ cd update2bundled
   $ cat <<EOF >> .hg/hgrc
   > [extensions]
   > strip =
   > EOF
   $ echo "aaa" >> a
   $ hg commit -A -m 0
   adding a
   $ echo "bbb" >> b
   $ hg commit -A -m 1
   adding b
   $ echo "ccc" >> c
   $ hg commit -A -m 2
   adding c
   $ hg update -r 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "ddd" >> d
   $ hg commit -A -m 3
   adding d
   created new head
   $ hg update -r 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   o  changeset:   3:8bd3e1f196af
   |  tag:         tip
   |  parent:      1:a01eca7af26d
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     3
   |
   | @  changeset:   2:4652c276ac4f
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     2
   |
   o  changeset:   1:a01eca7af26d
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     1
   |
   o  changeset:   0:4fe08cd4693e
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg bundle --base 1 -r 3 ../update2bundled.hg
   1 changesets found
   $ hg strip -r 3
   saved backup bundle to $TESTTMP/update2bundled/.hg/strip-backup/8bd3e1f196af-017e56d8-backup.hg (glob)
   $ hg merge -R ../update2bundled.hg -r 3
   setting parent to node 8bd3e1f196af289b2b121be08031e76d7ae92098 that only exists in the bundle
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 When user updates to the revision existing only in the bundle,
 it should show warning
 
   $ hg update -R ../update2bundled.hg --clean -r 3
   setting parent to node 8bd3e1f196af289b2b121be08031e76d7ae92098 that only exists in the bundle
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 When user updates to the revision existing in the local repository
 the warning shouldn't be emitted
 
   $ hg update -R ../update2bundled.hg -r 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved

tests/test-clonebundles.t

@@ -1,433 +1,434 b''
 Set up a server
 
   $ cat >> $HGRCPATH << EOF
   > [format]
   > usegeneraldelta=yes
   > EOF
   $ hg init server
   $ cd server
   $ cat >> .hg/hgrc << EOF
   > [extensions]
   > clonebundles =
   > EOF
 
   $ touch foo
   $ hg -q commit -A -m 'add foo'
   $ touch bar
   $ hg -q commit -A -m 'add bar'
 
   $ hg serve -d -p $HGPORT --pid-file hg.pid --accesslog access.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 
 Missing manifest should not result in server lookup
 
   $ hg --verbose clone -U http://localhost:$HGPORT no-manifest
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
   $ cat server/access.log
   * - - [*] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * - - [*] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D (glob)
   * - - [*] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bundlecaps=HG20%2Cbundle2%3DHG20%250Achangegroup%253D01%252C02%250Adigests%253Dmd5%252Csha1%252Csha512%250Aerror%253Dabort%252Cunsupportedcontent%252Cpushraced%252Cpushkey%250Ahgtagsfnodes%250Alistkeys%250Apushkey%250Aremote-changegroup%253Dhttp%252Chttps&cg=1&common=0000000000000000000000000000000000000000&heads=aaff8d2ffbbf07a46dd1f05d8ae7877e3f56e2a2&listkeys=phases%2Cbookmarks (glob)
 
 Empty manifest file results in retrieval
 (the extension only checks if the manifest file exists)
 
   $ touch server/.hg/clonebundles.manifest
   $ hg --verbose clone -U http://localhost:$HGPORT empty-manifest
   no clone bundles available on remote; falling back to regular clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
 Manifest file with invalid URL aborts
 
   $ echo 'http://does.not.exist/bundle.hg' > server/.hg/clonebundles.manifest
   $ hg clone http://localhost:$HGPORT 404-url
   applying clone bundle from http://does.not.exist/bundle.hg
   error fetching bundle: (.* not known|getaddrinfo failed|No address associated with hostname) (re)
   abort: error applying bundle
   (if this error persists, consider contacting the server operator or disable clone bundles via "--config ui.clonebundles=false")
   [255]
 
 Server is not running aborts
 
   $ echo "http://localhost:$HGPORT1/bundle.hg" > server/.hg/clonebundles.manifest
   $ hg clone http://localhost:$HGPORT server-not-runner
   applying clone bundle from http://localhost:$HGPORT1/bundle.hg
   error fetching bundle: * refused* (glob)
   abort: error applying bundle
   (if this error persists, consider contacting the server operator or disable clone bundles via "--config ui.clonebundles=false")
   [255]
 
 Server returns 404
 
   $ python $TESTDIR/dumbhttp.py -p $HGPORT1 --pid http.pid
   $ cat http.pid >> $DAEMON_PIDS
   $ hg clone http://localhost:$HGPORT running-404
   applying clone bundle from http://localhost:$HGPORT1/bundle.hg
   HTTP error fetching bundle: HTTP Error 404: File not found
   abort: error applying bundle
   (if this error persists, consider contacting the server operator or disable clone bundles via "--config ui.clonebundles=false")
   [255]
 
 We can override failure to fall back to regular clone
 
   $ hg --config ui.clonebundlefallback=true clone -U http://localhost:$HGPORT 404-fallback
   applying clone bundle from http://localhost:$HGPORT1/bundle.hg
   HTTP error fetching bundle: HTTP Error 404: File not found
   falling back to normal clone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
 Bundle with partial content works
 
   $ hg -R server bundle --type gzip-v1 --base null -r 53245c60e682 partial.hg
   1 changesets found
 
 We verify exact bundle content as an extra check against accidental future
 changes. If this output changes, we could break old clients.
 
   $ f --size --hexdump partial.hg
   partial.hg: size=207
   0000: 48 47 31 30 47 5a 78 9c 63 60 60 98 17 ac 12 93 |HG10GZx.c``.....|
   0010: f0 ac a9 23 45 70 cb bf 0d 5f 59 4e 4a 7f 79 21 |...#Ep..._YNJ.y!|
   0020: 9b cc 40 24 20 a0 d7 ce 2c d1 38 25 cd 24 25 d5 |..@$ ...,.8%.$%.|
   0030: d8 c2 22 cd 38 d9 24 cd 22 d5 c8 22 cd 24 cd 32 |..".8.$."..".$.2|
   0040: d1 c2 d0 c4 c8 d2 32 d1 38 39 29 c9 34 cd d4 80 |......2.89).4...|
   0050: ab 24 b5 b8 84 cb 40 c1 80 2b 2d 3f 9f 8b 2b 31 |.$....@..+-?..+1|
   0060: 25 45 01 c8 80 9a d2 9b 65 fb e5 9e 45 bf 8d 7f |%E......e...E...|
   0070: 9f c6 97 9f 2b 44 34 67 d9 ec 8e 0f a0 92 0b 75 |....+D4g.......u|
   0080: 41 d6 24 59 18 a4 a4 9a a6 18 1a 5b 98 9b 5a 98 |A.$Y.......[..Z.|
   0090: 9a 18 26 9b a6 19 98 1a 99 99 26 a6 18 9a 98 24 |..&.......&....$|
   00a0: 26 59 a6 25 5a 98 a5 18 a6 24 71 41 35 b1 43 dc |&Y.%Z....$qA5.C.|
   00b0: 16 b2 83 f7 e9 45 8b d2 56 c7 a3 1f 82 52 d7 8a |.....E..V....R..|
   00c0: 78 ed fc d5 76 f1 36 35 dc 05 00 36 ed 5e c7    |x...v.65...6.^.|
 
   $ echo "http://localhost:$HGPORT1/partial.hg" > server/.hg/clonebundles.manifest
   $ hg clone -U http://localhost:$HGPORT partial-bundle
   applying clone bundle from http://localhost:$HGPORT1/partial.hg
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   finished applying clone bundle
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
 Incremental pull doesn't fetch bundle
 
   $ hg clone -r 53245c60e682 -U http://localhost:$HGPORT partial-clone
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
 
   $ cd partial-clone
   $ hg pull
   pulling from http://localhost:$HGPORT/
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   (run 'hg update' to get a working copy)
   $ cd ..
 
 Bundle with full content works
 
   $ hg -R server bundle --type gzip-v2 --base null -r tip full.hg
   2 changesets found
 
 Again, we perform an extra check against bundle content changes. If this content
 changes, clone bundles produced by new Mercurial versions may not be readable
 by old clients.
 
   $ f --size --hexdump full.hg
-  full.hg: size=406
+  full.hg: size=418
   0000: 48 47 32 30 00 00 00 0e 43 6f 6d 70 72 65 73 73 |HG20....Compress|
-  0010: 69 6f 6e 3d 47 5a 78 9c 63 60 60 90 e5 76 f6 70 |ion=GZx.c``..v.p|
-  0020: f4 73 77 75 0f f2 0f 0d 60 00 02 46 06 76 a6 b2 |.swu....`..F.v..|
-  0030: d4 a2 e2 cc fc 3c 03 23 06 06 e6 65 40 b1 4d c1 |.....<.#...e@.M.|
-  0040: 2a 31 09 cf 9a 3a 52 04 b7 fc db f0 95 e5 a4 f4 |*1...:R.........|
-  0050: 97 17 b2 c9 0c 14 00 02 e6 d9 99 25 1a a7 a4 99 |...........%....|
-  0060: a4 a4 1a 5b 58 a4 19 27 9b a4 59 a4 1a 59 a4 99 |...[X..'..Y..Y..|
-  0070: a4 59 26 5a 18 9a 18 59 5a 26 1a 27 27 25 99 a6 |.Y&Z...YZ&.''%..|
-  0080: 99 1a 70 95 a4 16 97 70 19 28 18 70 a5 e5 e7 73 |..p....p.(.p...s|
-  0090: 71 25 a6 a4 28 00 19 40 13 0e ac fa df ab ff 7b |q%..(..@.......{|
-  00a0: 3f fb 92 dc 8b 1f 62 bb 9e b7 d7 d9 87 3d 5a 44 |?.....b......=ZD|
-  00b0: ac 2f b0 a9 c3 66 1e 54 b9 26 08 a7 1a 1b 1a a7 |./...f.T.&......|
-  00c0: 25 1b 9a 1b 99 19 9a 5a 18 9b a6 18 19 00 dd 67 |%......Z.......g|
-  00d0: 61 61 98 06 f4 80 49 4a 8a 65 52 92 41 9a 81 81 |aa....IJ.eR.A...|
-  00e0: a5 11 17 50 31 30 58 19 cc 80 98 25 29 b1 08 c4 |...P10X....%)...|
-  00f0: 37 07 79 19 88 d9 41 ee 07 8a 41 cd 5d 98 65 fb |7.y...A...A.].e.|
-  0100: e5 9e 45 bf 8d 7f 9f c6 97 9f 2b 44 34 67 d9 ec |..E.......+D4g..|
-  0110: 8e 0f a0 61 a8 eb 82 82 2e c9 c2 20 25 d5 34 c5 |...a....... %.4.|
-  0120: d0 d8 c2 dc d4 c2 d4 c4 30 d9 34 cd c0 d4 c8 cc |........0.4.....|
-  0130: 34 31 c5 d0 c4 24 31 c9 32 2d d1 c2 2c c5 30 25 |41...$1.2-..,.0%|
-  0140: 09 e4 ee 85 8f 85 ff 88 ab 89 36 c7 2a c4 47 34 |..........6.*.G4|
-  0150: fe f8 ec 7b 73 37 3f c3 24 62 1d 8d 4d 1d 9e 40 |...{s7?.$b..M..@|
-  0160: 06 3b 10 14 36 a4 38 10 04 d8 21 01 9a b1 83 f7 |.;..6.8...!.....|
-  0170: e9 45 8b d2 56 c7 a3 1f 82 52 d7 8a 78 ed fc d5 |.E..V....R..x...|
-  0180: 76 f1 36 25 81 89 c7 ad ec 90 34 48 75 2b 89 49 |v.6%......4Hu+.I|
-  0190: bf 00 d6 97 f0 8d                               |......|
+  0010: 69 6f 6e 3d 47 5a 78 9c 63 60 60 d0 e4 76 f6 70 |ion=GZx.c``..v.p|
+  0020: f4 73 77 75 0f f2 0f 0d 60 00 02 46 46 76 26 4e |.swu....`..FFv&N|
+  0030: c6 b2 d4 a2 e2 cc fc 3c 03 a3 bc a4 e4 8c c4 bc |.......<........|
+  0040: f4 d4 62 23 06 06 e6 65 40 f9 4d c1 2a 31 09 cf |..b#...e@.M.*1..|
+  0050: 9a 3a 52 04 b7 fc db f0 95 e5 a4 f4 97 17 b2 c9 |.:R.............|
+  0060: 0c 14 00 02 e6 d9 99 25 1a a7 a4 99 a4 a4 1a 5b |.......%.......[|
+  0070: 58 a4 19 27 9b a4 59 a4 1a 59 a4 99 a4 59 26 5a |X..'..Y..Y...Y&Z|
+  0080: 18 9a 18 59 5a 26 1a 27 27 25 99 a6 99 1a 70 95 |...YZ&.''%....p.|
+  0090: a4 16 97 70 19 28 18 70 a5 e5 e7 73 71 25 a6 a4 |...p.(.p...sq%..|
+  00a0: 28 00 19 40 13 0e ac fa df ab ff 7b 3f fb 92 dc |(..@.......{?...|
+  00b0: 8b 1f 62 bb 9e b7 d7 d9 87 3d 5a 44 ac 2f b0 a9 |..b......=ZD./..|
+  00c0: c3 66 1e 54 b9 26 08 a7 1a 1b 1a a7 25 1b 9a 1b |.f.T.&......%...|
+  00d0: 99 19 9a 5a 18 9b a6 18 19 00 dd 67 61 61 98 06 |...Z.......gaa..|
+  00e0: f4 80 49 4a 8a 65 52 92 41 9a 81 81 a5 11 17 50 |..IJ.eR.A......P|
+  00f0: 31 30 58 19 cc 80 98 25 29 b1 08 c4 37 07 79 19 |10X....%)...7.y.|
+  0100: 88 d9 41 ee 07 8a 41 cd 5d 98 65 fb e5 9e 45 bf |..A...A.].e...E.|
+  0110: 8d 7f 9f c6 97 9f 2b 44 34 67 d9 ec 8e 0f a0 61 |......+D4g.....a|
+  0120: a8 eb 82 82 2e c9 c2 20 25 d5 34 c5 d0 d8 c2 dc |....... %.4.....|
+  0130: d4 c2 d4 c4 30 d9 34 cd c0 d4 c8 cc 34 31 c5 d0 |....0.4.....41..|
+  0140: c4 24 31 c9 32 2d d1 c2 2c c5 30 25 09 e4 ee 85 |.$1.2-..,.0%....|
+  0150: 8f 85 ff 88 ab 89 36 c7 2a c4 47 34 fe f8 ec 7b |......6.*.G4...{|
+  0160: 73 37 3f c3 24 62 1d 8d 4d 1d 9e 40 06 3b 10 14 |s7?.$b..M..@.;..|
+  0170: 36 a4 38 10 04 d8 21 01 9a b1 83 f7 e9 45 8b d2 |6.8...!......E..|
+  0180: 56 c7 a3 1f 82 52 d7 8a 78 ed fc d5 76 f1 36 25 |V....R..x...v.6%|
+  0190: 81 89 c7 ad ec 90 34 48 75 2b 89 49 bf 00 cf 72 |......4Hu+.I...r|
+  01a0: f4 7f                                           |..|
 
   $ echo "http://localhost:$HGPORT1/full.hg" > server/.hg/clonebundles.manifest
   $ hg clone -U http://localhost:$HGPORT full-bundle
   applying clone bundle from http://localhost:$HGPORT1/full.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Feature works over SSH
 
   $ hg clone -U -e "python \"$TESTDIR/dummyssh\"" ssh://user@dummy/server ssh-full-clone
   applying clone bundle from http://localhost:$HGPORT1/full.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Entry with unknown BUNDLESPEC is filtered and not used
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://bad.entry1 BUNDLESPEC=UNKNOWN
   > http://bad.entry2 BUNDLESPEC=xz-v1
   > http://bad.entry3 BUNDLESPEC=none-v100
   > http://localhost:$HGPORT1/full.hg BUNDLESPEC=gzip-v2
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT filter-unknown-type
   applying clone bundle from http://localhost:$HGPORT1/full.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Automatic fallback when all entries are filtered
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://bad.entry BUNDLESPEC=UNKNOWN
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT filter-all
   no compatible clone bundles available on server; falling back to regular clone
   (you may want to report this to the server operator)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
 URLs requiring SNI are filtered in Python <2.7.9
 
   $ cp full.hg sni.hg
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/sni.hg REQUIRESNI=true
   > http://localhost:$HGPORT1/full.hg
   > EOF
 
 #if sslcontext
 Python 2.7.9+ support SNI
 
   $ hg clone -U http://localhost:$HGPORT sni-supported
   applying clone bundle from http://localhost:$HGPORT1/sni.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 #else
 Python <2.7.9 will filter SNI URLs
 
   $ hg clone -U http://localhost:$HGPORT sni-unsupported
   applying clone bundle from http://localhost:$HGPORT1/full.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 #endif
 
 Stream clone bundles are supported
 
   $ hg -R server debugcreatestreamclonebundle packed.hg
   writing 613 bytes for 4 files
   bundle requirements: generaldelta, revlogv1
 
 No bundle spec should work
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/packed.hg
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT stream-clone-no-spec
   applying clone bundle from http://localhost:$HGPORT1/packed.hg
   4 files to transfer, 613 bytes of data
   transferred 613 bytes in *.* seconds (*) (glob)
   finished applying clone bundle
   searching for changes
   no changes found
 
 Bundle spec without parameters should work
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/packed.hg BUNDLESPEC=none-packed1
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT stream-clone-vanilla-spec
   applying clone bundle from http://localhost:$HGPORT1/packed.hg
   4 files to transfer, 613 bytes of data
   transferred 613 bytes in *.* seconds (*) (glob)
   finished applying clone bundle
   searching for changes
   no changes found
 
 Bundle spec with format requirements should work
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/packed.hg BUNDLESPEC=none-packed1;requirements%3Drevlogv1
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT stream-clone-supported-requirements
   applying clone bundle from http://localhost:$HGPORT1/packed.hg
   4 files to transfer, 613 bytes of data
   transferred 613 bytes in *.* seconds (*) (glob)
   finished applying clone bundle
   searching for changes
   no changes found
 
 Stream bundle spec with unknown requirements should be filtered out
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/packed.hg BUNDLESPEC=none-packed1;requirements%3Drevlogv42
   > EOF
 
   $ hg clone -U http://localhost:$HGPORT stream-clone-unsupported-requirements
   no compatible clone bundles available on server; falling back to regular clone
   (you may want to report this to the server operator)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
 
 Set up manifest for testing preferences
 (Remember, the TYPE does not have to match reality - the URL is
 important)
 
   $ cp full.hg gz-a.hg
   $ cp full.hg gz-b.hg
   $ cp full.hg bz2-a.hg
   $ cp full.hg bz2-b.hg
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/gz-a.hg BUNDLESPEC=gzip-v2 extra=a
   > http://localhost:$HGPORT1/bz2-a.hg BUNDLESPEC=bzip2-v2 extra=a
   > http://localhost:$HGPORT1/gz-b.hg BUNDLESPEC=gzip-v2 extra=b
   > http://localhost:$HGPORT1/bz2-b.hg BUNDLESPEC=bzip2-v2 extra=b
   > EOF
 
 Preferring an undefined attribute will take first entry
 
   $ hg --config ui.clonebundleprefers=foo=bar clone -U http://localhost:$HGPORT prefer-foo
   applying clone bundle from http://localhost:$HGPORT1/gz-a.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Preferring bz2 type will download first entry of that type
 
   $ hg --config ui.clonebundleprefers=COMPRESSION=bzip2 clone -U http://localhost:$HGPORT prefer-bz
   applying clone bundle from http://localhost:$HGPORT1/bz2-a.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Preferring multiple values of an option works
 
   $ hg --config ui.clonebundleprefers=COMPRESSION=unknown,COMPRESSION=bzip2 clone -U http://localhost:$HGPORT prefer-multiple-bz
   applying clone bundle from http://localhost:$HGPORT1/bz2-a.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Sorting multiple values should get us back to original first entry
 
   $ hg --config ui.clonebundleprefers=BUNDLESPEC=unknown,BUNDLESPEC=gzip-v2,BUNDLESPEC=bzip2-v2 clone -U http://localhost:$HGPORT prefer-multiple-gz
   applying clone bundle from http://localhost:$HGPORT1/gz-a.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Preferring multiple attributes has correct order
 
   $ hg --config ui.clonebundleprefers=extra=b,BUNDLESPEC=bzip2-v2 clone -U http://localhost:$HGPORT prefer-separate-attributes
   applying clone bundle from http://localhost:$HGPORT1/bz2-b.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found
 
 Test where attribute is missing from some entries
 
   $ cat > server/.hg/clonebundles.manifest << EOF
   > http://localhost:$HGPORT1/gz-a.hg BUNDLESPEC=gzip-v2
   > http://localhost:$HGPORT1/bz2-a.hg BUNDLESPEC=bzip2-v2
   > http://localhost:$HGPORT1/gz-b.hg BUNDLESPEC=gzip-v2 extra=b
   > http://localhost:$HGPORT1/bz2-b.hg BUNDLESPEC=bzip2-v2 extra=b
   > EOF
 
   $ hg --config ui.clonebundleprefers=extra=b clone -U http://localhost:$HGPORT prefer-partially-defined-attribute
   applying clone bundle from http://localhost:$HGPORT1/gz-b.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   finished applying clone bundle
   searching for changes
   no changes found

tests/test-debugbundle.t

@@ -1,76 +1,76 b''
 
 Create a test repository:
 
   $ hg init repo
   $ cd repo
   $ touch a ; hg add a ; hg ci -ma
   $ touch b ; hg add b ; hg ci -mb
   $ touch c ; hg add c ; hg ci -mc
   $ hg bundle --base 0 --rev tip bundle.hg -v --type v1
   2 changesets found
   uncompressed size of bundle content:
        332 (changelog)
        282 (manifests)
         93  b
         93  c
   $ hg bundle --base 0 --rev tip bundle2.hg -v --type none-v2
   2 changesets found
   uncompressed size of bundle content:
        372 (changelog)
        322 (manifests)
        113  b
        113  c
 
 Terse output:
 
   $ hg debugbundle bundle.hg
   0e067c57feba1a5694ca4844f05588bb1bf82342
   991a3460af53952d10ec8a295d3d2cc2e5fa9690
 
 Terse output:
 
   $ hg debugbundle bundle2.hg
   Stream params: {}
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '2')])"
       0e067c57feba1a5694ca4844f05588bb1bf82342
       991a3460af53952d10ec8a295d3d2cc2e5fa9690
 
 Verbose output:
 
   $ hg debugbundle --all bundle.hg
   format: id, p1, p2, cset, delta base, len(delta)
   
   changelog
   0e067c57feba1a5694ca4844f05588bb1bf82342 3903775176ed42b1458a6281db4a0ccf4d9f287a 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 3903775176ed42b1458a6281db4a0ccf4d9f287a 80
   991a3460af53952d10ec8a295d3d2cc2e5fa9690 0e067c57feba1a5694ca4844f05588bb1bf82342 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 0e067c57feba1a5694ca4844f05588bb1bf82342 80
   
   manifest
   686dbf0aeca417636fa26a9121c681eabbb15a20 8515d4bfda768e04af4c13a69a72e28c7effbea7 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 8515d4bfda768e04af4c13a69a72e28c7effbea7 55
   ae25a31b30b3490a981e7b96a3238cc69583fda1 686dbf0aeca417636fa26a9121c681eabbb15a20 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 686dbf0aeca417636fa26a9121c681eabbb15a20 55
   
   b
   b80de5d138758541c5f05265ad144ab9fa86d1db 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 0000000000000000000000000000000000000000 0
   
   c
   b80de5d138758541c5f05265ad144ab9fa86d1db 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 0000000000000000000000000000000000000000 0
 
   $ hg debugbundle --all bundle2.hg
   Stream params: {}
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '2')])"
       format: id, p1, p2, cset, delta base, len(delta)
   
       changelog
       0e067c57feba1a5694ca4844f05588bb1bf82342 3903775176ed42b1458a6281db4a0ccf4d9f287a 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 3903775176ed42b1458a6281db4a0ccf4d9f287a 80
       991a3460af53952d10ec8a295d3d2cc2e5fa9690 0e067c57feba1a5694ca4844f05588bb1bf82342 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 0e067c57feba1a5694ca4844f05588bb1bf82342 80
   
       manifest
       686dbf0aeca417636fa26a9121c681eabbb15a20 8515d4bfda768e04af4c13a69a72e28c7effbea7 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 8515d4bfda768e04af4c13a69a72e28c7effbea7 55
       ae25a31b30b3490a981e7b96a3238cc69583fda1 686dbf0aeca417636fa26a9121c681eabbb15a20 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 686dbf0aeca417636fa26a9121c681eabbb15a20 55
   
       b
       b80de5d138758541c5f05265ad144ab9fa86d1db 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 0e067c57feba1a5694ca4844f05588bb1bf82342 0000000000000000000000000000000000000000 0
   
       c
       b80de5d138758541c5f05265ad144ab9fa86d1db 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 991a3460af53952d10ec8a295d3d2cc2e5fa9690 0000000000000000000000000000000000000000 0
 
   $ cd ..

tests/test-generaldelta.t

@@ -1,161 +1,161 b''
 Check whether size of generaldelta revlog is not bigger than its
 regular equivalent. Test would fail if generaldelta was naive
 implementation of parentdelta: third manifest revision would be fully
 inserted due to big distance from its paren revision (zero).
 
   $ hg init repo --config format.generaldelta=no --config format.usegeneraldelta=no
   $ cd repo
   $ echo foo > foo
   $ echo bar > bar
   $ echo baz > baz
   $ hg commit -q -Am boo
   $ hg clone --pull . ../gdrepo -q --config format.generaldelta=yes
   $ for r in 1 2 3; do
   >   echo $r > foo
   >   hg commit -q -m $r
   >   hg up -q -r 0
   >   hg pull . -q -r $r -R ../gdrepo
   > done
 
   $ cd ..
   >>> from __future__ import print_function
   >>> import os
   >>> regsize = os.stat("repo/.hg/store/00manifest.i").st_size
   >>> gdsize = os.stat("gdrepo/.hg/store/00manifest.i").st_size
   >>> if regsize < gdsize:
   ...     print('generaldata increased size of manifest')
 
 Verify rev reordering doesnt create invalid bundles (issue4462)
 This requires a commit tree that when pulled will reorder manifest revs such
 that the second manifest to create a file rev will be ordered before the first
 manifest to create that file rev. We also need to do a partial pull to ensure
 reordering happens. At the end we verify the linkrev points at the earliest
 commit.
 
   $ hg init server --config format.generaldelta=True
   $ cd server
   $ touch a
   $ hg commit -Aqm a
   $ echo x > x
   $ echo y > y
   $ hg commit -Aqm xy
   $ hg up -q '.^'
   $ echo x > x
   $ echo z > z
   $ hg commit -Aqm xz
   $ hg up -q 1
   $ echo b > b
   $ hg commit -Aqm b
   $ hg merge -q 2
   $ hg commit -Aqm merge
   $ echo c > c
   $ hg commit -Aqm c
   $ hg log -G -T '{rev} {shortest(node)} {desc}'
   @  5 ebb8 c
   |
   o    4 baf7 merge
   |\
   | o  3 a129 b
   | |
   o |  2 958c xz
   | |
   | o  1 f00c xy
   |/
   o  0 3903 a
   
   $ cd ..
   $ hg init client --config format.generaldelta=false --config format.usegeneraldelta=false
   $ cd client
   $ hg pull -q ../server -r 4
   $ hg debugindex x
      rev    offset  length   base linkrev nodeid       p1           p2
        0         0       3      0       1 1406e7411862 000000000000 000000000000
 
   $ cd ..
 
 Test "usegeneraldelta" config
 (repo are general delta, but incoming bundle are not re-deltified)
 
 delta coming from the server base delta server are not recompressed.
 (also include the aggressive version for comparison)
 
   $ hg clone repo --pull --config format.usegeneraldelta=1 usegd
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 6 changes to 3 files (+2 heads)
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg clone repo --pull --config format.generaldelta=1 full
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 6 changes to 3 files (+2 heads)
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R repo debugindex -m
      rev    offset  length   base linkrev nodeid       p1           p2
        0         0     104      0       0 cef96823c800 000000000000 000000000000
        1       104      57      0       1 58ab9a8d541d cef96823c800 000000000000
        2       161      57      0       2 134fdc6fd680 cef96823c800 000000000000
        3       218     104      3       3 723508934dad cef96823c800 000000000000
   $ hg -R usegd debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0     104     -1       0 cef96823c800 000000000000 000000000000
        1       104      57      0       1 58ab9a8d541d cef96823c800 000000000000
        2       161      57      1       2 134fdc6fd680 cef96823c800 000000000000
        3       218      57      0       3 723508934dad cef96823c800 000000000000
   $ hg -R full debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0     104     -1       0 cef96823c800 000000000000 000000000000
        1       104      57      0       1 58ab9a8d541d cef96823c800 000000000000
        2       161      57      0       2 134fdc6fd680 cef96823c800 000000000000
        3       218      57      0       3 723508934dad cef96823c800 000000000000
 
 Test format.aggressivemergedeltas
 
   $ hg init --config format.generaldelta=1 aggressive
   $ cd aggressive
   $ cat << EOF >> .hg/hgrc
   > [format]
   > generaldelta = 1
   > EOF
   $ touch a b c d e
   $ hg commit -Aqm side1
   $ hg up -q null
   $ touch x y
   $ hg commit -Aqm side2
 
 - Verify non-aggressive merge uses p1 (commit 1) as delta parent
   $ hg merge -q 0
   $ hg commit -q -m merge
   $ hg debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0      59     -1       0 8dde941edb6e 000000000000 000000000000
        1        59      61      0       1 315c023f341d 000000000000 000000000000
        2       120      65      1       2 2ab389a983eb 315c023f341d 8dde941edb6e
 
   $ hg strip -q -r . --config extensions.strip=
 
 - Verify aggressive merge uses p2 (commit 0) as delta parent
   $ hg up -q -C 1
   $ hg merge -q 0
   $ hg commit -q -m merge --config format.aggressivemergedeltas=True
   $ hg debugindex -m
      rev    offset  length  delta linkrev nodeid       p1           p2
        0         0      59     -1       0 8dde941edb6e 000000000000 000000000000
        1        59      61      0       1 315c023f341d 000000000000 000000000000
        2       120      62      0       2 2ab389a983eb 315c023f341d 8dde941edb6e
 
 Test that strip bundle use bundle2
   $ hg --config extensions.strip= strip .
   0 files updated, 0 files merged, 5 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/aggressive/.hg/strip-backup/1c5d4dc9a8b8-6c68e60c-backup.hg (glob)
   $ hg debugbundle .hg/strip-backup/*
   Stream params: sortdict([('Compression', 'BZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       1c5d4dc9a8b8d6e1750966d343e94db665e7a1e9
 
   $ cd ..

tests/test-getbundle.t

@@ -1,272 +1,272 b''
 #require serve
 
 = Test the getbundle() protocol function =
 
 Create a test repository:
 
   $ hg init repo
   $ cd repo
   $ hg debugbuilddag -n -m '+2 :fork +5 :p1 *fork +6 :p2 /p1 :m1 +3' > /dev/null
   $ hg log -G --template '{node}\n'
   o  10c14a2cc935e1d8c31f9e98587dcf27fb08a6da
   |
   o  4801a72e5d88cb515b0c7e40fae34180f3f837f2
   |
   o  0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   |
   o    8365676dbab05860ce0d9110f2af51368b961bbd
   |\
   | o  5686dbbd9fc46cb806599c878d02fe1cb56b83d3
   | |
   | o  13c0170174366b441dc68e8e33757232fa744458
   | |
   | o  63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   | |
   | o  700b7e19db54103633c4bf4a6a6b6d55f4d50c03
   | |
   | o  928b5f94cdb278bb536eba552de348a4e92ef24d
   | |
   | o  f34414c64173e0ecb61b25dc55e116dbbcc89bee
   | |
   | o  8931463777131cd73923e560b760061f2aa8a4bc
   | |
   o |  6621d79f61b23ec74cf4b69464343d9e0980ec8b
   | |
   o |  bac16991d12ff45f9dc43c52da1946dfadb83e80
   | |
   o |  ff42371d57168345fdf1a3aac66a51f6a45d41d2
   | |
   o |  d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   | |
   o |  713346a995c363120712aed1aee7e04afd867638
   |/
   o  29a4d1f17bd3f0779ca0525bebb1cfb51067c738
   |
   o  7704483d56b2a7b5db54dcee7c62378ac629b348
   
   $ cd ..
 
 
 = Test locally =
 
 Get everything:
 
   $ hg debuggetbundle repo bundle
   $ hg debugbundle bundle
   7704483d56b2a7b5db54dcee7c62378ac629b348
   29a4d1f17bd3f0779ca0525bebb1cfb51067c738
   713346a995c363120712aed1aee7e04afd867638
   d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   6621d79f61b23ec74cf4b69464343d9e0980ec8b
   8931463777131cd73923e560b760061f2aa8a4bc
   f34414c64173e0ecb61b25dc55e116dbbcc89bee
   928b5f94cdb278bb536eba552de348a4e92ef24d
   700b7e19db54103633c4bf4a6a6b6d55f4d50c03
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   13c0170174366b441dc68e8e33757232fa744458
   5686dbbd9fc46cb806599c878d02fe1cb56b83d3
   8365676dbab05860ce0d9110f2af51368b961bbd
   0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   4801a72e5d88cb515b0c7e40fae34180f3f837f2
   10c14a2cc935e1d8c31f9e98587dcf27fb08a6da
 
 Get part of linear run:
 
   $ hg debuggetbundle repo bundle -H 4801a72e5d88cb515b0c7e40fae34180f3f837f2 -C 8365676dbab05860ce0d9110f2af51368b961bbd
   $ hg debugbundle bundle
   0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   4801a72e5d88cb515b0c7e40fae34180f3f837f2
 
 Get missing branch and merge:
 
   $ hg debuggetbundle repo bundle -H 4801a72e5d88cb515b0c7e40fae34180f3f837f2 -C 13c0170174366b441dc68e8e33757232fa744458
   $ hg debugbundle bundle
   713346a995c363120712aed1aee7e04afd867638
   d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   6621d79f61b23ec74cf4b69464343d9e0980ec8b
   5686dbbd9fc46cb806599c878d02fe1cb56b83d3
   8365676dbab05860ce0d9110f2af51368b961bbd
   0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   4801a72e5d88cb515b0c7e40fae34180f3f837f2
 
 Get from only one head:
 
   $ hg debuggetbundle repo bundle -H 928b5f94cdb278bb536eba552de348a4e92ef24d -C 29a4d1f17bd3f0779ca0525bebb1cfb51067c738
   $ hg debugbundle bundle
   8931463777131cd73923e560b760061f2aa8a4bc
   f34414c64173e0ecb61b25dc55e116dbbcc89bee
   928b5f94cdb278bb536eba552de348a4e92ef24d
 
 Get parts of two branches:
 
   $ hg debuggetbundle repo bundle -H 13c0170174366b441dc68e8e33757232fa744458 -C 700b7e19db54103633c4bf4a6a6b6d55f4d50c03 -H bac16991d12ff45f9dc43c52da1946dfadb83e80 -C d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   $ hg debugbundle bundle
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   13c0170174366b441dc68e8e33757232fa744458
 
 Check that we get all needed file changes:
 
   $ hg debugbundle bundle --all
   format: id, p1, p2, cset, delta base, len(delta)
   
   changelog
   ff42371d57168345fdf1a3aac66a51f6a45d41d2 d5f6e1ea452285324836a49d7d3c2a63cfed1d31 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 d5f6e1ea452285324836a49d7d3c2a63cfed1d31 99
   bac16991d12ff45f9dc43c52da1946dfadb83e80 ff42371d57168345fdf1a3aac66a51f6a45d41d2 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 ff42371d57168345fdf1a3aac66a51f6a45d41d2 99
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043 700b7e19db54103633c4bf4a6a6b6d55f4d50c03 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 bac16991d12ff45f9dc43c52da1946dfadb83e80 102
   13c0170174366b441dc68e8e33757232fa744458 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 102
   
   manifest
   dac7984588fc4eea7acbf39693a9c1b06f5b175d 591f732a3faf1fb903815273f3c199a514a61ccb 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 591f732a3faf1fb903815273f3c199a514a61ccb 113
   0772616e6b48a76afb6c1458e193cbb3dae2e4ff dac7984588fc4eea7acbf39693a9c1b06f5b175d 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 dac7984588fc4eea7acbf39693a9c1b06f5b175d 113
   eb498cd9af6c44108e43041e951ce829e29f6c80 bff2f4817ced57b386caf7c4e3e36a4bc9af7e93 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0772616e6b48a76afb6c1458e193cbb3dae2e4ff 295
   b15709c071ddd2d93188508ba156196ab4f19620 eb498cd9af6c44108e43041e951ce829e29f6c80 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 eb498cd9af6c44108e43041e951ce829e29f6c80 114
   
   mf
   4f73f97080266ab8e0c0561ca8d0da3eaf65b695 301ca08d026bb72cb4258a9d211bdf7ca0bcd810 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 301ca08d026bb72cb4258a9d211bdf7ca0bcd810 17
   c7b583de053293870e145f45bd2d61643563fd06 4f73f97080266ab8e0c0561ca8d0da3eaf65b695 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 4f73f97080266ab8e0c0561ca8d0da3eaf65b695 18
   266ee3c0302a5a18f1cf96817ac79a51836179e9 edc0f6b8db80d68ae6aff2b19f7e5347ab68fa63 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 c7b583de053293870e145f45bd2d61643563fd06 149
   698c6a36220548cd3903ca7dada27c59aa500c52 266ee3c0302a5a18f1cf96817ac79a51836179e9 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 266ee3c0302a5a18f1cf96817ac79a51836179e9 19
   
   nf11
   33fbc651630ffa7ccbebfe4eb91320a873e7291c 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0000000000000000000000000000000000000000 16
   
   nf12
   ddce0544363f037e9fb889faca058f52dc01c0a5 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 0000000000000000000000000000000000000000 16
   
   nf4
   3c1407305701051cbed9f9cb9a68bdfb5997c235 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 0000000000000000000000000000000000000000 15
   
   nf5
   0dbd89c185f53a1727c54cd1ce256482fa23968e 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 0000000000000000000000000000000000000000 15
 
 Get branch and merge:
 
   $ hg debuggetbundle repo bundle -C 7704483d56b2a7b5db54dcee7c62378ac629b348 -H 0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   $ hg debugbundle bundle
   29a4d1f17bd3f0779ca0525bebb1cfb51067c738
   713346a995c363120712aed1aee7e04afd867638
   d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   6621d79f61b23ec74cf4b69464343d9e0980ec8b
   8931463777131cd73923e560b760061f2aa8a4bc
   f34414c64173e0ecb61b25dc55e116dbbcc89bee
   928b5f94cdb278bb536eba552de348a4e92ef24d
   700b7e19db54103633c4bf4a6a6b6d55f4d50c03
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   13c0170174366b441dc68e8e33757232fa744458
   5686dbbd9fc46cb806599c878d02fe1cb56b83d3
   8365676dbab05860ce0d9110f2af51368b961bbd
   0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
 
 = Test bundle2 =
 
   $ hg debuggetbundle repo bundle -t bundle2
   $ hg debugbundle bundle
   Stream params: {}
-  changegroup -- "sortdict([('version', '01')])"
+  changegroup -- "sortdict([('version', '01'), ('nbchanges', '18')])"
       7704483d56b2a7b5db54dcee7c62378ac629b348
       29a4d1f17bd3f0779ca0525bebb1cfb51067c738
       713346a995c363120712aed1aee7e04afd867638
       d5f6e1ea452285324836a49d7d3c2a63cfed1d31
       ff42371d57168345fdf1a3aac66a51f6a45d41d2
       bac16991d12ff45f9dc43c52da1946dfadb83e80
       6621d79f61b23ec74cf4b69464343d9e0980ec8b
       8931463777131cd73923e560b760061f2aa8a4bc
       f34414c64173e0ecb61b25dc55e116dbbcc89bee
       928b5f94cdb278bb536eba552de348a4e92ef24d
       700b7e19db54103633c4bf4a6a6b6d55f4d50c03
       63476832d8ec6558cf9bbe3cbe0c757e5cf18043
       13c0170174366b441dc68e8e33757232fa744458
       5686dbbd9fc46cb806599c878d02fe1cb56b83d3
       8365676dbab05860ce0d9110f2af51368b961bbd
       0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
       4801a72e5d88cb515b0c7e40fae34180f3f837f2
       10c14a2cc935e1d8c31f9e98587dcf27fb08a6da
 = Test via HTTP =
 
 Get everything:
 
   $ hg serve -R repo -p $HGPORT -d --pid-file=hg.pid -E error.log -A access.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ hg debuggetbundle http://localhost:$HGPORT/ bundle
   $ hg debugbundle bundle
   7704483d56b2a7b5db54dcee7c62378ac629b348
   29a4d1f17bd3f0779ca0525bebb1cfb51067c738
   713346a995c363120712aed1aee7e04afd867638
   d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   6621d79f61b23ec74cf4b69464343d9e0980ec8b
   8931463777131cd73923e560b760061f2aa8a4bc
   f34414c64173e0ecb61b25dc55e116dbbcc89bee
   928b5f94cdb278bb536eba552de348a4e92ef24d
   700b7e19db54103633c4bf4a6a6b6d55f4d50c03
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   13c0170174366b441dc68e8e33757232fa744458
   5686dbbd9fc46cb806599c878d02fe1cb56b83d3
   8365676dbab05860ce0d9110f2af51368b961bbd
   0b2f73f04880d9cb6a5cd8a757f0db0ad01e32c3
   4801a72e5d88cb515b0c7e40fae34180f3f837f2
   10c14a2cc935e1d8c31f9e98587dcf27fb08a6da
 
 Get parts of two branches:
 
   $ hg debuggetbundle http://localhost:$HGPORT/ bundle -H 13c0170174366b441dc68e8e33757232fa744458 -C 700b7e19db54103633c4bf4a6a6b6d55f4d50c03 -H bac16991d12ff45f9dc43c52da1946dfadb83e80 -C d5f6e1ea452285324836a49d7d3c2a63cfed1d31
   $ hg debugbundle bundle
   ff42371d57168345fdf1a3aac66a51f6a45d41d2
   bac16991d12ff45f9dc43c52da1946dfadb83e80
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043
   13c0170174366b441dc68e8e33757232fa744458
 
 Check that we get all needed file changes:
 
   $ hg debugbundle bundle --all
   format: id, p1, p2, cset, delta base, len(delta)
   
   changelog
   ff42371d57168345fdf1a3aac66a51f6a45d41d2 d5f6e1ea452285324836a49d7d3c2a63cfed1d31 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 d5f6e1ea452285324836a49d7d3c2a63cfed1d31 99
   bac16991d12ff45f9dc43c52da1946dfadb83e80 ff42371d57168345fdf1a3aac66a51f6a45d41d2 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 ff42371d57168345fdf1a3aac66a51f6a45d41d2 99
   63476832d8ec6558cf9bbe3cbe0c757e5cf18043 700b7e19db54103633c4bf4a6a6b6d55f4d50c03 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 bac16991d12ff45f9dc43c52da1946dfadb83e80 102
   13c0170174366b441dc68e8e33757232fa744458 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 102
   
   manifest
   dac7984588fc4eea7acbf39693a9c1b06f5b175d 591f732a3faf1fb903815273f3c199a514a61ccb 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 591f732a3faf1fb903815273f3c199a514a61ccb 113
   0772616e6b48a76afb6c1458e193cbb3dae2e4ff dac7984588fc4eea7acbf39693a9c1b06f5b175d 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 dac7984588fc4eea7acbf39693a9c1b06f5b175d 113
   eb498cd9af6c44108e43041e951ce829e29f6c80 bff2f4817ced57b386caf7c4e3e36a4bc9af7e93 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0772616e6b48a76afb6c1458e193cbb3dae2e4ff 295
   b15709c071ddd2d93188508ba156196ab4f19620 eb498cd9af6c44108e43041e951ce829e29f6c80 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 eb498cd9af6c44108e43041e951ce829e29f6c80 114
   
   mf
   4f73f97080266ab8e0c0561ca8d0da3eaf65b695 301ca08d026bb72cb4258a9d211bdf7ca0bcd810 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 301ca08d026bb72cb4258a9d211bdf7ca0bcd810 17
   c7b583de053293870e145f45bd2d61643563fd06 4f73f97080266ab8e0c0561ca8d0da3eaf65b695 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 4f73f97080266ab8e0c0561ca8d0da3eaf65b695 18
   266ee3c0302a5a18f1cf96817ac79a51836179e9 edc0f6b8db80d68ae6aff2b19f7e5347ab68fa63 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 c7b583de053293870e145f45bd2d61643563fd06 149
   698c6a36220548cd3903ca7dada27c59aa500c52 266ee3c0302a5a18f1cf96817ac79a51836179e9 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 266ee3c0302a5a18f1cf96817ac79a51836179e9 19
   
   nf11
   33fbc651630ffa7ccbebfe4eb91320a873e7291c 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 63476832d8ec6558cf9bbe3cbe0c757e5cf18043 0000000000000000000000000000000000000000 16
   
   nf12
   ddce0544363f037e9fb889faca058f52dc01c0a5 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 13c0170174366b441dc68e8e33757232fa744458 0000000000000000000000000000000000000000 16
   
   nf4
   3c1407305701051cbed9f9cb9a68bdfb5997c235 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 ff42371d57168345fdf1a3aac66a51f6a45d41d2 0000000000000000000000000000000000000000 15
   
   nf5
   0dbd89c185f53a1727c54cd1ce256482fa23968e 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 bac16991d12ff45f9dc43c52da1946dfadb83e80 0000000000000000000000000000000000000000 15
 
 Verify we hit the HTTP server:
 
   $ cat access.log
   * - - [*] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * - - [*] "GET /?cmd=getbundle HTTP/1.1" 200 - (glob)
   * - - [*] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * - - [*] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:common=700b7e19db54103633c4bf4a6a6b6d55f4d50c03+d5f6e1ea452285324836a49d7d3c2a63cfed1d31&heads=13c0170174366b441dc68e8e33757232fa744458+bac16991d12ff45f9dc43c52da1946dfadb83e80 (glob)
 
   $ cat error.log
 

tests/test-patchbomb.t

@@ -1,2909 +1,2909 b''
 Note for future hackers of patchbomb: this file is a bit heavy on
 wildcards in test expectations due to how many things like hostnames
 tend to make it into outputs. As a result, you may need to perform the
 following regular expression substitutions:
 @$HOSTNAME> -> @*> (glob)
 Mercurial-patchbomb/.* -> Mercurial-patchbomb/* (glob)
 /mixed; boundary="===+[0-9]+==" -> /mixed; boundary="===*== (glob)"
 --===+[0-9]+=+--$ -> --===*=-- (glob)
 --===+[0-9]+=+$ -> --===*= (glob)
 
   $ cat > prune-blank-after-boundary.py <<EOF
   > import sys
   > skipblank = False
   > trim = lambda x: x.strip(' \r\n')
   > for l in sys.stdin:
   >     if trim(l).endswith('=--') or trim(l).endswith('=='):
   >         skipblank = True
   >         print l,
   >         continue
   >     if not trim(l) and skipblank:
   >         continue
   >     skipblank = False
   >     print l,
   > EOF
   $ FILTERBOUNDARY="python `pwd`/prune-blank-after-boundary.py"
   $ echo "[format]" >> $HGRCPATH
   $ echo "usegeneraldelta=yes" >> $HGRCPATH
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "patchbomb=" >> $HGRCPATH
 
 Ensure hg email output is sent to stdout
   $ unset PAGER
 
   $ hg init t
   $ cd t
   $ echo a > a
   $ hg commit -Ama -d '1 0'
   adding a
 
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -r tip
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <8580ff50825a50c8f716.60@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
   $ hg --config ui.interactive=1 email --confirm -n -f quux -t foo -c bar -r tip<<EOF
   > n
   > EOF
   this patch series consists of 1 patches.
   
   
   Final summary:
   
   From: quux
   To: foo
   Cc: bar
   Subject: [PATCH] a
    a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   are you sure you want to send (yn)? n
   abort: patchbomb canceled
   [255]
 
   $ hg --config ui.interactive=1 --config patchbomb.confirm=true email -n -f quux -t foo -c bar -r tip<<EOF
   > n
   > EOF
   this patch series consists of 1 patches.
   
   
   Final summary:
   
   From: quux
   To: foo
   Cc: bar
   Subject: [PATCH] a
    a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   are you sure you want to send (yn)? n
   abort: patchbomb canceled
   [255]
 
 
 Test diff.git is respected
   $ hg --config diff.git=True email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -r tip
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <8580ff50825a50c8f716.60@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff --git a/a b/a
   new file mode 100644
   --- /dev/null
   +++ b/a
   @@ -0,0 +1,1 @@
   +a
   
 
 
 Test breaking format changes aren't
   $ hg --config diff.noprefix=True email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -r tip
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <8580ff50825a50c8f716.60@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
 
   $ echo b > b
   $ hg commit -Amb -d '2 0'
   adding b
 
   $ hg email --date '1970-1-1 0:2' -n -f quux -t foo -c bar -s test -r 0:tip
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2] test
   Message-Id: <patchbomb.120@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:02:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.121@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.121@*> (glob)
   In-Reply-To: <patchbomb.120@*> (glob)
   References: <patchbomb.120@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:02:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.122@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.121@*> (glob)
   In-Reply-To: <patchbomb.120@*> (glob)
   References: <patchbomb.120@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:02:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 .hg/last-email.txt
 
   $ cat > editor.sh << '__EOF__'
   > echo "a precious introductory message" > "$1"
   > __EOF__
   $ HGEDITOR="\"sh\" \"`pwd`/editor.sh\"" hg email -n -t foo -s test -r 0:tip > /dev/null
   $ cat .hg/last-email.txt
   a precious introductory message
 
   $ hg email -m test.mbox -f quux -t foo -c bar -s test 0:tip \
   > --config extensions.progress= --config progress.assume-tty=1 \
   > --config progress.delay=0 --config progress.refresh=0 \
   > --config progress.width=60
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   \r (no-eol) (esc)
   sending [                                             ] 0/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   sending [==============>                              ] 1/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   sending [=============================>               ] 2/3\r (no-eol) (esc)
                                                               \r (esc)
   sending [PATCH 0 of 2] test ...
   sending [PATCH 1 of 2] a ...
   sending [PATCH 2 of 2] b ...
 
   $ cd ..
 
   $ hg clone -q t t2
   $ cd t2
   $ echo c > c
   $ hg commit -Amc -d '3 0'
   adding c
 
   $ cat > description <<EOF
   > a multiline
   > 
   > description
   > EOF
 
 
 test bundle and description:
   $ hg email --date '1970-1-1 0:3' -n -f quux -t foo \
   >  -c bar -s test -r tip -b --desc description | $FILTERBOUNDARY
   searching for changes
   1 changesets found
   
   displaying test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: test
   Message-Id: <patchbomb.180@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:03:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   a multiline
   
   description
   
   --===*= (glob)
   Content-Type: application/x-mercurial-bundle
   MIME-Version: 1.0
   Content-Disposition: attachment; filename="bundle.hg"
   Content-Transfer-Encoding: base64
   
-  SEcyMAAAAA5Db21wcmVzc2lvbj1CWkJaaDkxQVkmU1lCZFwPAAAKf//7nFYSWD1/4H7R09C/I70I
-  Ak0E4peoSIYIgQCgGUQOcLABGY2hqoAAAaBMTTAAAahgTCZoAAAAAMQaqn5GmapojQ00DEGI/VGJ
-  kDAJoGTDUAAyM0QaAEqalPTUaMhoyDIDR6IxAGEGmgAehMRhDRsoyB6TYTC8JyLN+jTGqitRAgRJ
-  b3SRlhd8/+VxlAUqAilLoKPEEyxFQkaEGo+DzItFeNiFAo8NMMweVtvXJFIMhjoKC18DeYwjLKBz
-  wrMcs86qJrctDNJorwBMuLcqvTVWHh1IlsIaaaYSUIP2IZsogT1+pSSZS+bSTJrgfKsO9go/f0HF
-  uW4Yr2vXpxDreOgSIAdK/xC8Yay48SLpxIuqc/BZ6rVZCgG21rr0zhCaEgXOTqNaYEvANvg0B0Qo
-  dgtqAs1FDcZgzYitwJh6ZAG0C4mA7FPrp9b7h0h/A44Xgd+0it1gvF0mFE/CCPwymXS+OisOOCAF
-  mDUDAC1pBvsXckU4UJBCZFwP
+  SEcyMAAAAA5Db21wcmVzc2lvbj1CWkJaaDkxQVkmU1kIqE7KAAAKf//7vFYQWD1/4H7R09C/470I
+  Ak0E4peoSIYIgQCgGUQOcLABGY2hqoTTCYaBqaYAAACaaMAATIwAA1MIYDaQaqn6p+jRop+oJkA2
+  oNqD1PU0PUBoxqaMmjMUepoBoDT1GmQNBKmlTT1GTCNMEAYTQ0NNDI0BoMQHpAZAA8o2pkyNJHfX
+  RRbXoyxKRUlAg41B3lpmMOnr77dEpFKAvEUGEkWuC4wioiMjC2Y2a84EXhsNCFIrbXUGId07PJnS
+  ELAOIpL/gE8R8CUeXuw2NKMtkFoLPkcTSomXtgHSg1IKaCNlWwVU3CpmMYqh5gkFYJKOD4UhVVQ6
+  SiF1DpE8ghWvF1ih+fYgagfYHI96w/QsrRATpYiP7VRbINFrQy2c21mZ7M4pXXrPBypoXAIhtum7
+  aKDJCpUqMDF5dfiDChMfgH9nQ4B60Uvgb4AK9dsbSYc+O3tEyNq9g9gZeA5Je2T82GzjC4DbY4F2
+  0kdrTBwslErFshCgDzeEBwICg13oQaQawQA1WWd3F3JFOFCQCKhOyg==
   --===============*==-- (glob)
 
 with a specific bundle type
 (binary part must be different)
 
   $ hg email --date '1970-1-1 0:3' -n -f quux -t foo \
   >  -c bar -s test -r tip -b --desc description \
   > --config patchbomb.bundletype=gzip-v1 | $FILTERBOUNDARY
   searching for changes
   1 changesets found
   
   displaying test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: test
   Message-Id: <patchbomb.180@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:03:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   a multiline
   
   description
   
   --===*= (glob)
   Content-Type: application/x-mercurial-bundle
   MIME-Version: 1.0
   Content-Disposition: attachment; filename="bundle.hg"
   Content-Transfer-Encoding: base64
   
   SEcxMEdaeJxjYGBY8V9n/iLGbtFfJZuNk/euDCpWfrRy/vTrevFCx1/4t7J5LdeL0ix0Opx3kwEL
   wKYXKqUJwqnG5sYWSWmmJsaWlqYWaRaWJpaWiWamZpYWRgZGxolJiabmSQbmZqlcQMV6QGwCxGzG
   CgZcySARUyA2A2LGZKiZ3Y+Lu786z4z4MWXmsrAZCsqrl1az5y21PMcjpbThzWeXGT+/nutbmvvz
   zXYS3BoGxdrJDIYmlimJJiZpRokmqYYmaSYWFknmSSkmhqbmliamiZYWxuYmBhbJBgZcUBNZQe5K
   Epm7xF/LT+RLx/a9juFTomaYO/Rgsx4rwBN+IMCUDLOKAQBrsmti
   --===============*==-- (glob)
 
 utf-8 patch:
   $ $PYTHON -c 'fp = open("utf", "wb"); fp.write("h\xC3\xB6mma!\n"); fp.close();'
   $ hg commit -A -d '4 0' -m 'utf-8 content'
   adding description
   adding utf
 
 no mime encoding for email --test:
   $ hg email --date '1970-1-1 0:4' -f quux -t foo -c bar -r tip -n
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] utf-8 content ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 8bit
   Subject: [PATCH] utf-8 content
   X-Mercurial-Node: 909a00e13e9d78b575aeee23dddbada46d5a143f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <909a00e13e9d78b575ae.240@*> (glob)
   X-Mercurial-Series-Id: <909a00e13e9d78b575ae.240@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:04:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID 909a00e13e9d78b575aeee23dddbada46d5a143f
   # Parent  ff2c9fa2018b15fa74b33363bda9527323e2a99f
   utf-8 content
   
   diff -r ff2c9fa2018b -r 909a00e13e9d description
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/description	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,3 @@
   +a multiline
   +
   +description
   diff -r ff2c9fa2018b -r 909a00e13e9d utf
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/utf	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +h\xc3\xb6mma! (esc)
   
 
 mime encoded mbox (base64):
   $ hg email --date '1970-1-1 0:4' -f 'Q <quux>' -t foo -c bar -r tip -m mbox
   this patch series consists of 1 patches.
   
   
   sending [PATCH] utf-8 content ...
 
   $ cat mbox
   From quux ... ... .. ..:..:.. .... (re)
   Content-Type: text/plain; charset="utf-8"
   MIME-Version: 1.0
   Content-Transfer-Encoding: base64
   Subject: [PATCH] utf-8 content
   X-Mercurial-Node: 909a00e13e9d78b575aeee23dddbada46d5a143f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <909a00e13e9d78b575ae.240@*> (glob)
   X-Mercurial-Series-Id: <909a00e13e9d78b575ae.240@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:04:00 +0000
   From: Q <quux>
   To: foo
   Cc: bar
   
   IyBIRyBjaGFuZ2VzZXQgcGF0Y2gKIyBVc2VyIHRlc3QKIyBEYXRlIDQgMAojICAgICAgVGh1IEph
   biAwMSAwMDowMDowNCAxOTcwICswMDAwCiMgTm9kZSBJRCA5MDlhMDBlMTNlOWQ3OGI1NzVhZWVl
   MjNkZGRiYWRhNDZkNWExNDNmCiMgUGFyZW50ICBmZjJjOWZhMjAxOGIxNWZhNzRiMzMzNjNiZGE5
   NTI3MzIzZTJhOTlmCnV0Zi04IGNvbnRlbnQKCmRpZmYgLXIgZmYyYzlmYTIwMThiIC1yIDkwOWEw
   MGUxM2U5ZCBkZXNjcmlwdGlvbgotLS0gL2Rldi9udWxsCVRodSBKYW4gMDEgMDA6MDA6MDAgMTk3
   MCArMDAwMAorKysgYi9kZXNjcmlwdGlvbglUaHUgSmFuIDAxIDAwOjAwOjA0IDE5NzAgKzAwMDAK
   QEAgLTAsMCArMSwzIEBACithIG11bHRpbGluZQorCitkZXNjcmlwdGlvbgpkaWZmIC1yIGZmMmM5
   ZmEyMDE4YiAtciA5MDlhMDBlMTNlOWQgdXRmCi0tLSAvZGV2L251bGwJVGh1IEphbiAwMSAwMDow
   MDowMCAxOTcwICswMDAwCisrKyBiL3V0ZglUaHUgSmFuIDAxIDAwOjAwOjA0IDE5NzAgKzAwMDAK
   QEAgLTAsMCArMSwxIEBACitow7ZtbWEhCg==
   
   
   $ $PYTHON -c 'print open("mbox").read().split("\n\n")[1].decode("base64")'
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID 909a00e13e9d78b575aeee23dddbada46d5a143f
   # Parent  ff2c9fa2018b15fa74b33363bda9527323e2a99f
   utf-8 content
   
   diff -r ff2c9fa2018b -r 909a00e13e9d description
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/description	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,3 @@
   +a multiline
   +
   +description
   diff -r ff2c9fa2018b -r 909a00e13e9d utf
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/utf	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +h\xc3\xb6mma! (esc)
   
   $ rm mbox
 
 mime encoded mbox (quoted-printable):
   $ $PYTHON -c 'fp = open("long", "wb"); fp.write("%s\nfoo\n\nbar\n" % ("x" * 1024)); fp.close();'
   $ hg commit -A -d '4 0' -m 'long line'
   adding long
 
 no mime encoding for email --test:
   $ hg email --date '1970-1-1 0:4' -f quux -t foo -c bar -r tip -n
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] long line ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Subject: [PATCH] long line
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <a2ea8fc83dd8b93cfd86.240@*> (glob)
   X-Mercurial-Series-Id: <a2ea8fc83dd8b93cfd86.240@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:04:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
 
 mime encoded mbox (quoted-printable):
   $ hg email --date '1970-1-1 0:4' -f quux -t foo -c bar -r tip -m mbox
   this patch series consists of 1 patches.
   
   
   sending [PATCH] long line ...
   $ cat mbox
   From quux ... ... .. ..:..:.. .... (re)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Subject: [PATCH] long line
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <a2ea8fc83dd8b93cfd86.240@*> (glob)
   X-Mercurial-Series-Id: <a2ea8fc83dd8b93cfd86.240@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:04:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   
 
   $ rm mbox
 
 iso-8859-1 patch:
   $ $PYTHON -c 'fp = open("isolatin", "wb"); fp.write("h\xF6mma!\n"); fp.close();'
   $ hg commit -A -d '5 0' -m 'isolatin 8-bit encoding'
   adding isolatin
 
 fake ascii mbox:
   $ hg email --date '1970-1-1 0:5' -f quux -t foo -c bar -r tip -m mbox
   this patch series consists of 1 patches.
   
   
   sending [PATCH] isolatin 8-bit encoding ...
   $ cat mbox
   From quux ... ... .. ..:..:.. .... (re)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 8bit
   Subject: [PATCH] isolatin 8-bit encoding
   X-Mercurial-Node: 240fb913fc1b7ff15ddb9f33e73d82bf5277c720
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <240fb913fc1b7ff15ddb.300@*> (glob)
   X-Mercurial-Series-Id: <240fb913fc1b7ff15ddb.300@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:05:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 5 0
   #      Thu Jan 01 00:00:05 1970 +0000
   # Node ID 240fb913fc1b7ff15ddb9f33e73d82bf5277c720
   # Parent  a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   isolatin 8-bit encoding
   
   diff -r a2ea8fc83dd8 -r 240fb913fc1b isolatin
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/isolatin	Thu Jan 01 00:00:05 1970 +0000
   @@ -0,0 +1,1 @@
   +h\xf6mma! (esc)
   
   
 
 test diffstat for single patch:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -d -y -r 2
   this patch series consists of 1 patches.
   
   
   Final summary:
   
   From: quux
   To: foo
   Cc: bar
   Subject: [PATCH] test
    c |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   are you sure you want to send (yn)? y
   
   displaying [PATCH] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
    c |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test diffstat for multiple patches:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -d -y \
   >  -r 0:1
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   Final summary:
   
   From: quux
   To: foo
   Cc: bar
   Subject: [PATCH 0 of 2] test
    a |  1 +
    b |  1 +
    2 files changed, 2 insertions(+), 0 deletions(-)
   Subject: [PATCH 1 of 2] a
    a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   Subject: [PATCH 2 of 2] b
    b |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   are you sure you want to send (yn)? y
   
   displaying [PATCH 0 of 2] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
    a |  1 +
    b |  1 +
    2 files changed, 2 insertions(+), 0 deletions(-)
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
    a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
    b |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 test inline for single patch:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -i -r 2 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=t2.patch
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   --===*=-- (glob)
 
 
 test inline for single patch (quoted-printable):
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -i -r 4 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <a2ea8fc83dd8b93cfd86.60@*> (glob)
   X-Mercurial-Series-Id: <a2ea8fc83dd8b93cfd86.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Content-Disposition: inline; filename=t2.patch
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   --===*=-- (glob)
 
 test inline for multiple patches:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -i \
   >  -r 0:1 -r 4 | $FILTERBOUNDARY
   this patch series consists of 3 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 3] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 3] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 3] a ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 1 of 3] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 3
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=t2-1.patch
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   --===*=-- (glob)
   displaying [PATCH 2 of 3] b ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 2 of 3] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 3
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=t2-2.patch
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   --===*=-- (glob)
   displaying [PATCH 3 of 3] long line ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 3 of 3] long line
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 3
   X-Mercurial-Series-Total: 3
   Message-Id: <a2ea8fc83dd8b93cfd86.63@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:03 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Content-Disposition: inline; filename=t2-3.patch
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   --===*=-- (glob)
 
 test attach for single patch:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -a -r 2 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   Patch subject is complete summary.
   
   
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: attachment; filename=t2.patch
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   --===*=-- (glob)
 
 test attach for single patch (quoted-printable):
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -a -r 4 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <a2ea8fc83dd8b93cfd86.60@*> (glob)
   X-Mercurial-Series-Id: <a2ea8fc83dd8b93cfd86.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   Patch subject is complete summary.
   
   
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Content-Disposition: attachment; filename=t2.patch
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   --===*=-- (glob)
 
 test attach and body for single patch:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -a --body -r 2 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: attachment; filename=t2.patch
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   --===*=-- (glob)
 
 test attach for multiple patches:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -a \
   >  -r 0:1 -r 4 | $FILTERBOUNDARY
   this patch series consists of 3 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 3] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 3] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 3] a ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 1 of 3] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 3
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   Patch subject is complete summary.
   
   
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: attachment; filename=t2-1.patch
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   --===*=-- (glob)
   displaying [PATCH 2 of 3] b ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 2 of 3] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 3
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   Patch subject is complete summary.
   
   
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: attachment; filename=t2-2.patch
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   --===*=-- (glob)
   displaying [PATCH 3 of 3] long line ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 3 of 3] long line
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 3
   X-Mercurial-Series-Total: 3
   Message-Id: <a2ea8fc83dd8b93cfd86.63@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:03 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   
   Patch subject is complete summary.
   
   
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Content-Disposition: attachment; filename=t2-3.patch
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   --===*=-- (glob)
 
 test intro for single patch:
   $ hg email --date '1970-1-1 0:1' -n --intro -f quux -t foo -c bar -s test \
   >  -r 2
   this patch series consists of 1 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 1] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 1] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 1] c ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 1] c
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.61@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test --desc without --intro for a single patch:
   $ echo foo > intro.text
   $ hg email --date '1970-1-1 0:1' -n --desc intro.text -f quux -t foo -c bar \
   >  -s test -r 2
   this patch series consists of 1 patches.
   
   
   displaying [PATCH 0 of 1] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 1] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   foo
   
   displaying [PATCH 1 of 1] c ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 1] c
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.61@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test intro for multiple patches:
   $ hg email --date '1970-1-1 0:1' -n --intro -f quux -t foo -c bar -s test \
   >  -r 0:1
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 test reply-to via config:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -r 2 \
   >  --config patchbomb.reply-to='[e-mail]'
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   Reply-To: [e-mail]
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test reply-to via command line:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -r 2 \
   >  --reply-to baz --reply-to fred
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   Reply-To: baz, fred
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 tagging csets:
   $ hg tag -r0 zero zero.foo
   $ hg tag -r1 one one.patch
   $ hg tag -r2 two two.diff
 
 test inline for single named patch:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -i \
   >   -r 2 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=two.diff
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   --===*=-- (glob)
 
 test inline for multiple named/unnamed patches:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar -s test -i \
   >    -r 0:1 | $FILTERBOUNDARY
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=t2-1.patch
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   --===*=-- (glob)
   displaying [PATCH 2 of 2] b ...
   Content-Type: multipart/mixed; boundary="===*==" (glob)
   MIME-Version: 1.0
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   --===*= (glob)
   Content-Type: text/x-patch; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Content-Disposition: inline; filename=one.patch
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   --===*=-- (glob)
 
 
 test inreplyto:
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar --in-reply-to baz \
   >  -r tip
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] Added tag two, two.diff for changeset ff2c9fa2018b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] Added tag two, two.diff for changeset ff2c9fa2018b
   X-Mercurial-Node: 7aead2484924c445ad8ce2613df91f52f9e502ed
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <7aead2484924c445ad8c.60@*> (glob)
   X-Mercurial-Series-Id: <7aead2484924c445ad8c.60@*> (glob)
   In-Reply-To: <baz>
   References: <baz>
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 7aead2484924c445ad8ce2613df91f52f9e502ed
   # Parent  045ca29b1ea20e4940411e695e20e521f2f0f98e
   Added tag two, two.diff for changeset ff2c9fa2018b
   
   diff -r 045ca29b1ea2 -r 7aead2484924 .hgtags
   --- a/.hgtags	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hgtags	Thu Jan 01 00:00:00 1970 +0000
   @@ -2,3 +2,5 @@
    8580ff50825a50c8f716709acdf8de0deddcd6ab zero.foo
    97d72e5f12c7e84f85064aa72e5a297142c36ed9 one
    97d72e5f12c7e84f85064aa72e5a297142c36ed9 one.patch
   +ff2c9fa2018b15fa74b33363bda9527323e2a99f two
   +ff2c9fa2018b15fa74b33363bda9527323e2a99f two.diff
   
 no intro message in non-interactive mode
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar --in-reply-to baz \
   >  -r 0:1
   this patch series consists of 2 patches.
   
   (optional) Subject: [PATCH 0 of 2] 
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.60@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.60@*> (glob)
   In-Reply-To: <baz>
   References: <baz>
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.60@*> (glob)
   In-Reply-To: <baz>
   References: <baz>
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 
 
   $ hg email --date '1970-1-1 0:1' -n -f quux -t foo -c bar --in-reply-to baz \
   >  -s test -r 0:1
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2] test
   Message-Id: <patchbomb.60@*> (glob)
   In-Reply-To: <baz>
   References: <baz>
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 test single flag for single patch (and no warning when not mailing dirty rev):
   $ hg up -qr1
   $ echo dirt > a
   $ hg email --date '1970-1-1 0:1' -n --flag fooFlag -f quux -t foo -c bar -s test \
   >  -r 2 | $FILTERBOUNDARY
   this patch series consists of 1 patches.
   
   
   displaying [PATCH fooFlag] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH fooFlag] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test single flag for multiple patches (and warning when mailing dirty rev):
   $ hg email --date '1970-1-1 0:1' -n --flag fooFlag -f quux -t foo -c bar -s test \
   >  -r 0:1
   warning: working directory has uncommitted changes
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2 fooFlag] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2 fooFlag] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2 fooFlag] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2 fooFlag] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2 fooFlag] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2 fooFlag] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
   $ hg revert --no-b a
   $ hg up -q
 
 test multiple flags for single patch:
   $ hg email --date '1970-1-1 0:1' -n --flag fooFlag --flag barFlag -f quux -t foo \
   >  -c bar -s test -r 2
   this patch series consists of 1 patches.
   
   
   displaying [PATCH fooFlag barFlag] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH fooFlag barFlag] test
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
 
 test multiple flags for multiple patches:
   $ hg email --date '1970-1-1 0:1' -n --flag fooFlag --flag barFlag -f quux -t foo \
   >  -c bar -s test -r 0:1
   this patch series consists of 2 patches.
   
   
   Write the introductory message for the patch series.
   
   
   displaying [PATCH 0 of 2 fooFlag barFlag] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 2 fooFlag barFlag] test
   Message-Id: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:00 +0000
   From: quux
   To: foo
   Cc: bar
   
   
   displaying [PATCH 1 of 2 fooFlag barFlag] a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 2 fooFlag barFlag] a
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 2
   Message-Id: <8580ff50825a50c8f716.61@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:01 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   displaying [PATCH 2 of 2 fooFlag barFlag] b ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 2 of 2 fooFlag barFlag] b
   X-Mercurial-Node: 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 2
   Message-Id: <97d72e5f12c7e84f8506.62@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.61@*> (glob)
   In-Reply-To: <patchbomb.60@*> (glob)
   References: <patchbomb.60@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Thu, 01 Jan 1970 00:01:02 +0000
   From: quux
   To: foo
   Cc: bar
   
   # HG changeset patch
   # User test
   # Date 2 0
   #      Thu Jan 01 00:00:02 1970 +0000
   # Node ID 97d72e5f12c7e84f85064aa72e5a297142c36ed9
   # Parent  8580ff50825a50c8f716709acdf8de0deddcd6ab
   b
   
   diff -r 8580ff50825a -r 97d72e5f12c7 b
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:02 1970 +0000
   @@ -0,0 +1,1 @@
   +b
   
 
 test multi-address parsing:
   $ hg email --date '1980-1-1 0:1' -m tmp.mbox -f quux -t 'spam<spam><eggs>' \
   >  -t toast -c 'foo,[e-mail]' -c '"A, B <>" <[e-mail]>' -s test -r 0 \
   >  --config email.bcc='"Quux, A." <quux>'
   this patch series consists of 1 patches.
   
   
   sending [PATCH] test ...
   $ cat < tmp.mbox
   From quux ... ... .. ..:..:.. .... (re)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <8580ff50825a50c8f716.315532860@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:00 +0000
   From: quux
   To: spam <spam>, eggs, toast
   Cc: foo, [e-mail], "A, B <>" <[e-mail]>
   Bcc: "Quux, A." <quux>
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   
 
 test multi-byte domain parsing:
   $ UUML=`$PYTHON -c 'import sys; sys.stdout.write("\374")'`
   $ HGENCODING=iso-8859-1
   $ export HGENCODING
   $ hg email --date '1980-1-1 0:1' -m tmp.mbox -f quux -t "bar@${UUML}nicode.com" -s test -r 0
   this patch series consists of 1 patches.
   
   Cc: 
   
   sending [PATCH] test ...
 
   $ cat tmp.mbox
   From quux ... ... .. ..:..:.. .... (re)
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: 8580ff50825a50c8f716709acdf8de0deddcd6ab
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <8580ff50825a50c8f716.315532860@*> (glob)
   X-Mercurial-Series-Id: <8580ff50825a50c8f716.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:00 +0000
   From: quux
   To: [e-mail]
   
   # HG changeset patch
   # User test
   # Date 1 0
   #      Thu Jan 01 00:00:01 1970 +0000
   # Node ID 8580ff50825a50c8f716709acdf8de0deddcd6ab
   # Parent  0000000000000000000000000000000000000000
   a
   
   diff -r 000000000000 -r 8580ff50825a a
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -0,0 +1,1 @@
   +a
   
   
 
 test outgoing:
   $ hg up 1
   0 files updated, 0 files merged, 6 files removed, 0 files unresolved
 
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
 
   $ echo d > d
   $ hg add d
   $ hg ci -md -d '4 0'
   $ echo d >> d
   $ hg ci -mdd -d '5 0'
   $ hg log -G --template "{rev}:{node|short} {desc|firstline}\n"
   @  10:3b6f1ec9dde9 dd
   |
   o  9:2f9fa9b998c5 d
   |
   | o  8:7aead2484924 Added tag two, two.diff for changeset ff2c9fa2018b
   | |
   | o  7:045ca29b1ea2 Added tag one, one.patch for changeset 97d72e5f12c7
   | |
   | o  6:5d5ef15dfe5e Added tag zero, zero.foo for changeset 8580ff50825a
   | |
   | o  5:240fb913fc1b isolatin 8-bit encoding
   | |
   | o  4:a2ea8fc83dd8 long line
   | |
   | o  3:909a00e13e9d utf-8 content
   | |
   | o  2:ff2c9fa2018b c
   |/
   o  1:97d72e5f12c7 b
   |
   o  0:8580ff50825a a
   
   $ hg phase --force --secret -r 10
   $ hg email --date '1980-1-1 0:1' -n -t foo -s test -o ../t -r 'rev(10) or rev(6)'
   comparing with ../t
   From [test]: test
   this patch series consists of 6 patches.
   
   
   Write the introductory message for the patch series.
   
   Cc: 
   
   displaying [PATCH 0 of 6] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 0 of 6] test
   Message-Id: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:00 +0000
   From: test
   To: foo
   
   
   displaying [PATCH 1 of 6] c ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 1 of 6] c
   X-Mercurial-Node: ff2c9fa2018b15fa74b33363bda9527323e2a99f
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 6
   Message-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:01 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 3 0
   #      Thu Jan 01 00:00:03 1970 +0000
   # Node ID ff2c9fa2018b15fa74b33363bda9527323e2a99f
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   c
   
   diff -r 97d72e5f12c7 -r ff2c9fa2018b c
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/c	Thu Jan 01 00:00:03 1970 +0000
   @@ -0,0 +1,1 @@
   +c
   
   displaying [PATCH 2 of 6] utf-8 content ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 8bit
   Subject: [PATCH 2 of 6] utf-8 content
   X-Mercurial-Node: 909a00e13e9d78b575aeee23dddbada46d5a143f
   X-Mercurial-Series-Index: 2
   X-Mercurial-Series-Total: 6
   Message-Id: <909a00e13e9d78b575ae.315532862@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:02 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID 909a00e13e9d78b575aeee23dddbada46d5a143f
   # Parent  ff2c9fa2018b15fa74b33363bda9527323e2a99f
   utf-8 content
   
   diff -r ff2c9fa2018b -r 909a00e13e9d description
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/description	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,3 @@
   +a multiline
   +
   +description
   diff -r ff2c9fa2018b -r 909a00e13e9d utf
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/utf	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +h\xc3\xb6mma! (esc)
   
   displaying [PATCH 3 of 6] long line ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: quoted-printable
   Subject: [PATCH 3 of 6] long line
   X-Mercurial-Node: a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   X-Mercurial-Series-Index: 3
   X-Mercurial-Series-Total: 6
   Message-Id: <a2ea8fc83dd8b93cfd86.315532863@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:03 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Node ID a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   # Parent  909a00e13e9d78b575aeee23dddbada46d5a143f
   long line
   
   diff -r 909a00e13e9d -r a2ea8fc83dd8 long
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/long	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,4 @@
   +xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   +foo
   +
   +bar
   
   displaying [PATCH 4 of 6] isolatin 8-bit encoding ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 8bit
   Subject: [PATCH 4 of 6] isolatin 8-bit encoding
   X-Mercurial-Node: 240fb913fc1b7ff15ddb9f33e73d82bf5277c720
   X-Mercurial-Series-Index: 4
   X-Mercurial-Series-Total: 6
   Message-Id: <240fb913fc1b7ff15ddb.315532864@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:04 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 5 0
   #      Thu Jan 01 00:00:05 1970 +0000
   # Node ID 240fb913fc1b7ff15ddb9f33e73d82bf5277c720
   # Parent  a2ea8fc83dd8b93cfd86ac97b28287204ab806e1
   isolatin 8-bit encoding
   
   diff -r a2ea8fc83dd8 -r 240fb913fc1b isolatin
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/isolatin	Thu Jan 01 00:00:05 1970 +0000
   @@ -0,0 +1,1 @@
   +h\xf6mma! (esc)
   
   displaying [PATCH 5 of 6] Added tag zero, zero.foo for changeset 8580ff50825a ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 5 of 6] Added tag zero, zero.foo for changeset 8580ff50825a
   X-Mercurial-Node: 5d5ef15dfe5e7bd3a4ee154b5fff76c7945ec433
   X-Mercurial-Series-Index: 5
   X-Mercurial-Series-Total: 6
   Message-Id: <5d5ef15dfe5e7bd3a4ee.315532865@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:05 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 5d5ef15dfe5e7bd3a4ee154b5fff76c7945ec433
   # Parent  240fb913fc1b7ff15ddb9f33e73d82bf5277c720
   Added tag zero, zero.foo for changeset 8580ff50825a
   
   diff -r 240fb913fc1b -r 5d5ef15dfe5e .hgtags
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/.hgtags	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,2 @@
   +8580ff50825a50c8f716709acdf8de0deddcd6ab zero
   +8580ff50825a50c8f716709acdf8de0deddcd6ab zero.foo
   
   displaying [PATCH 6 of 6] d ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH 6 of 6] d
   X-Mercurial-Node: 2f9fa9b998c5fe3ac2bd9a2b14bfcbeecbc7c268
   X-Mercurial-Series-Index: 6
   X-Mercurial-Series-Total: 6
   Message-Id: <2f9fa9b998c5fe3ac2bd.315532866@*> (glob)
   X-Mercurial-Series-Id: <ff2c9fa2018b15fa74b3.315532861@*> (glob)
   In-Reply-To: <patchbomb.315532860@*> (glob)
   References: <patchbomb.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:06 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Branch test
   # Node ID 2f9fa9b998c5fe3ac2bd9a2b14bfcbeecbc7c268
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   d
   
   diff -r 97d72e5f12c7 -r 2f9fa9b998c5 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +d
   
 
 Don't prompt for a CC header.
 
   $ echo "[email]" >> $HGRCPATH
   $ echo "cc=" >> $HGRCPATH
 
 dest#branch URIs:
   $ hg email --date '1980-1-1 0:1' -n -t foo -s test -o ../t#test
   comparing with ../t
   From [test]: test
   this patch series consists of 1 patches.
   
   
   displaying [PATCH] test ...
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: 2f9fa9b998c5fe3ac2bd9a2b14bfcbeecbc7c268
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <2f9fa9b998c5fe3ac2bd.315532860@*> (glob)
   X-Mercurial-Series-Id: <2f9fa9b998c5fe3ac2bd.315532860@*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:00 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 4 0
   #      Thu Jan 01 00:00:04 1970 +0000
   # Branch test
   # Node ID 2f9fa9b998c5fe3ac2bd9a2b14bfcbeecbc7c268
   # Parent  97d72e5f12c7e84f85064aa72e5a297142c36ed9
   d
   
   diff -r 97d72e5f12c7 -r 2f9fa9b998c5 d
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/d	Thu Jan 01 00:00:04 1970 +0000
   @@ -0,0 +1,1 @@
   +d
   
 
 Set up a fake sendmail program
 
   $ cat > pretendmail.sh << 'EOF'
   > #!/bin/sh
   > echo "$@"
   > cat
   > EOF
   $ chmod +x pretendmail.sh
 
   $ echo '[email]' >> $HGRCPATH
   $ echo "method=`pwd`/pretendmail.sh" >> $HGRCPATH
 
 Test introduction configuration
 =================================
 
   $ echo '[patchbomb]' >> $HGRCPATH
 
 "auto" setting
 ----------------
 
   $ echo 'intro=auto' >> $HGRCPATH
 
 single rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' | grep "Write the introductory message for the patch series."
   [1]
 
 single rev + flag
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' --intro | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 
 Multi rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '9::' | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 "never" setting
 -----------------
 
   $ echo 'intro=never' >> $HGRCPATH
 
 single rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' | grep "Write the introductory message for the patch series."
   [1]
 
 single rev + flag
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' --intro | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 
 Multi rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '9::' | grep "Write the introductory message for the patch series."
   [1]
 
 Multi rev + flag
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '9::' --intro | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 "always" setting
 -----------------
 
   $ echo 'intro=always' >> $HGRCPATH
 
 single rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 single rev + flag
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' --intro | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 
 Multi rev
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '9::' | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 Multi rev + flag
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '9::' --intro | grep "Write the introductory message for the patch series."
   Write the introductory message for the patch series.
 
 bad value setting
 -----------------
 
   $ echo 'intro=mpmwearaclownnose' >> $HGRCPATH
 
 single rev
 
   $ hg email --date '1980-1-1 0:1' -v -t foo -s test -r '10'
   From [test]: test
   this patch series consists of 1 patches.
   
   warning: invalid patchbomb.intro value "mpmwearaclownnose"
   (should be one of always, never, auto)
   -f test foo
   Content-Type: text/plain; charset="us-ascii"
   MIME-Version: 1.0
   Content-Transfer-Encoding: 7bit
   Subject: [PATCH] test
   X-Mercurial-Node: 3b6f1ec9dde933a40a115a7990f8b320477231af
   X-Mercurial-Series-Index: 1
   X-Mercurial-Series-Total: 1
   Message-Id: <3b6f1ec9dde933a40a11*> (glob)
   X-Mercurial-Series-Id: <3b6f1ec9dde933a40a11.*> (glob)
   User-Agent: Mercurial-patchbomb/* (glob)
   Date: Tue, 01 Jan 1980 00:01:00 +0000
   From: test
   To: foo
   
   # HG changeset patch
   # User test
   # Date 5 0
   #      Thu Jan 01 00:00:05 1970 +0000
   # Branch test
   # Node ID 3b6f1ec9dde933a40a115a7990f8b320477231af
   # Parent  2f9fa9b998c5fe3ac2bd9a2b14bfcbeecbc7c268
   dd
   
   diff -r 2f9fa9b998c5 -r 3b6f1ec9dde9 d
   --- a/d	Thu Jan 01 00:00:04 1970 +0000
   +++ b/d	Thu Jan 01 00:00:05 1970 +0000
   @@ -1,1 +1,2 @@
    d
   +d
   
   sending [PATCH] test ...
   sending mail: $TESTTMP/t2/pretendmail.sh -f test foo
 
 Test pull url header
 =================================
 
 basic version
 
   $ echo 'intro=auto' >> $HGRCPATH
   $ echo "publicurl=$TESTTMP/t2" >> $HGRCPATH
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10' | grep '^#'
   abort: public url $TESTTMP/t2 is missing 3b6f1ec9dde9
   (use 'hg push $TESTTMP/t2 -r 3b6f1ec9dde9')
   [1]
 
 public missing
 
   $ echo 'publicurl=$TESTTMP/missing' >> $HGRCPATH
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10'
   unable to access public repo: $TESTTMP/missing
   abort: repository $TESTTMP/missing not found!
   [255]
 
 node missing at public
 
   $ hg clone -r '9' . ../t3
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files
   updating to branch test
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'publicurl=$TESTTMP/t3' >> $HGRCPATH
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '10'
   abort: public url $TESTTMP/t3 is missing 3b6f1ec9dde9
   (use 'hg push $TESTTMP/t3 -r 3b6f1ec9dde9')
   [255]
 
 multiple heads are missing at public
 
   $ hg email --date '1980-1-1 0:1' -t foo -s test -r '2+10'
   abort: public "$TESTTMP/t3" is missing ff2c9fa2018b and 1 others
   (use 'hg push $TESTTMP/t3 -r ff2c9fa2018b -r 3b6f1ec9dde9')
   [255]
 

tests/test-rebase-conflicts.t

@@ -1,359 +1,359 b''
   $ cat >> $HGRCPATH <<EOF
   > [format]
   > usegeneraldelta=yes
   > [extensions]
   > rebase=
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}:{phase} '{desc}' {branches} {bookmarks}\n"
   > EOF
 
   $ hg init a
   $ cd a
   $ echo c1 >common
   $ hg add common
   $ hg ci -m C1
 
   $ echo c2 >>common
   $ hg ci -m C2
 
   $ echo c3 >>common
   $ hg ci -m C3
 
   $ hg up -q -C 1
 
   $ echo l1 >>extra
   $ hg add extra
   $ hg ci -m L1
   created new head
 
   $ sed -e 's/c2/l2/' common > common.new
   $ mv common.new common
   $ hg ci -m L2
 
   $ echo l3 >> extra2
   $ hg add extra2
   $ hg ci -m L3
   $ hg bookmark mybook
 
   $ hg phase --force --secret 4
 
   $ hg tglog
   @  5:secret 'L3'  mybook
   |
   o  4:secret 'L2'
   |
   o  3:draft 'L1'
   |
   | o  2:draft 'C3'
   |/
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 Try to call --continue:
 
   $ hg rebase --continue
   abort: no rebase in progress
   [255]
 
 Conflicting rebase:
 
   $ hg rebase -s 3 -d 2
   rebasing 3:3163e20567cc "L1"
   rebasing 4:46f0b057b5c0 "L2"
   merging common
   warning: conflicts while merging common! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
 
 Try to continue without solving the conflict:
 
   $ hg rebase --continue
   already rebased 3:3163e20567cc "L1" as 3e046f2ecedb
   rebasing 4:46f0b057b5c0 "L2"
   abort: unresolved merge conflicts (see "hg help resolve")
   [255]
 
 Conclude rebase:
 
   $ echo 'resolved merge' >common
   $ hg resolve -m common
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   already rebased 3:3163e20567cc "L1" as 3e046f2ecedb
   rebasing 4:46f0b057b5c0 "L2"
   rebasing 5:8029388f38dc "L3" (mybook)
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/3163e20567cc-5ca4656e-backup.hg (glob)
 
   $ hg tglog
   @  5:secret 'L3'  mybook
   |
   o  4:secret 'L2'
   |
   o  3:draft 'L1'
   |
   o  2:draft 'C3'
   |
   o  1:draft 'C2'
   |
   o  0:draft 'C1'
   
 Check correctness:
 
   $ hg cat -r 0 common
   c1
 
   $ hg cat -r 1 common
   c1
   c2
 
   $ hg cat -r 2 common
   c1
   c2
   c3
 
   $ hg cat -r 3 common
   c1
   c2
   c3
 
   $ hg cat -r 4 common
   resolved merge
 
   $ hg cat -r 5 common
   resolved merge
 
 Bookmark stays active after --continue
   $ hg bookmarks
    * mybook                    5:d67b21408fc0
 
   $ cd ..
 
 Check that the right ancestors is used while rebasing a merge (issue4041)
 
   $ hg clone "$TESTDIR/bundles/issue4041.hg" issue4041
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 8 changes to 3 files (+1 heads)
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd issue4041
   $ hg log -G
   o    changeset:   10:2f2496ddf49d
   |\   branch:      f1
   | |  tag:         tip
   | |  parent:      7:4c9fbe56a16f
   | |  parent:      9:e31216eec445
   | |  user:        szhang
   | |  date:        Thu Sep 05 12:59:39 2013 -0400
   | |  summary:     merge
   | |
   | o  changeset:   9:e31216eec445
   | |  branch:      f1
   | |  user:        szhang
   | |  date:        Thu Sep 05 12:59:10 2013 -0400
   | |  summary:     more changes to f1
   | |
   | o    changeset:   8:8e4e2c1a07ae
   | |\   branch:      f1
   | | |  parent:      2:4bc80088dc6b
   | | |  parent:      6:400110238667
   | | |  user:        szhang
   | | |  date:        Thu Sep 05 12:57:59 2013 -0400
   | | |  summary:     bad merge
   | | |
   o | |  changeset:   7:4c9fbe56a16f
   |/ /   branch:      f1
   | |    parent:      2:4bc80088dc6b
   | |    user:        szhang
   | |    date:        Thu Sep 05 12:54:00 2013 -0400
   | |    summary:     changed f1
   | |
   | o  changeset:   6:400110238667
   | |  branch:      f2
   | |  parent:      4:12e8ec6bb010
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:58:02 2013 -0400
   | |  summary:     changed f2 on f2
   | |
   | | @  changeset:   5:d79e2059b5c0
   | | |  parent:      3:8a951942e016
   | | |  user:        szhang
   | | |  date:        Tue Sep 03 13:57:39 2013 -0400
   | | |  summary:     changed f2 on default
   | | |
   | o |  changeset:   4:12e8ec6bb010
   | |/   branch:      f2
   | |    user:        szhang
   | |    date:        Tue Sep 03 13:57:18 2013 -0400
   | |    summary:     created f2 branch
   | |
   | o  changeset:   3:8a951942e016
   | |  parent:      0:24797d4f68de
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:57:11 2013 -0400
   | |  summary:     added f2.txt
   | |
   o |  changeset:   2:4bc80088dc6b
   | |  branch:      f1
   | |  user:        szhang
   | |  date:        Tue Sep 03 13:56:20 2013 -0400
   | |  summary:     added f1.txt
   | |
   o |  changeset:   1:ef53c9e6b608
   |/   branch:      f1
   |    user:        szhang
   |    date:        Tue Sep 03 13:55:26 2013 -0400
   |    summary:     created f1 branch
   |
   o  changeset:   0:24797d4f68de
      user:        szhang
      date:        Tue Sep 03 13:55:08 2013 -0400
      summary:     added default.txt
   
   $ hg rebase -s9 -d2 --debug # use debug to really check merge base used
   rebase onto 2 starting from e31216eec445
   ignoring null merge rebase of 3
   ignoring null merge rebase of 4
   ignoring null merge rebase of 6
   ignoring null merge rebase of 8
   rebasing 9:e31216eec445 "more changes to f1"
    future parents are 2 and -1
   rebase status stored
    update to 2:4bc80088dc6b
   resolving manifests
    branchmerge: False, force: True, partial: False
    ancestor: d79e2059b5c0+, local: d79e2059b5c0+, remote: 4bc80088dc6b
    f2.txt: other deleted -> r
   removing f2.txt
    f1.txt: remote created -> g
   getting f1.txt
    merge against 9:e31216eec445
      detach base 8:8e4e2c1a07ae
     searching for copies back to rev 3
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: 8e4e2c1a07ae, local: 4bc80088dc6b+, remote: e31216eec445
    f1.txt: remote is newer -> g
   getting f1.txt
   committing files:
   f1.txt
   committing manifest
   committing changelog
   rebased as 19c888675e13
   rebasing 10:2f2496ddf49d "merge" (tip)
    future parents are 11 and 7
   rebase status stored
    already in target
    merge against 10:2f2496ddf49d
      detach base 9:e31216eec445
     searching for copies back to rev 3
   resolving manifests
    branchmerge: True, force: True, partial: False
    ancestor: e31216eec445, local: 19c888675e13+, remote: 2f2496ddf49d
    f1.txt: remote is newer -> g
   getting f1.txt
   committing files:
   f1.txt
   committing manifest
   committing changelog
   rebased as 2a7f09cac94c
   rebase merging completed
   update back to initial working directory parent
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 2a7f09cac94c, local: 2a7f09cac94c+, remote: d79e2059b5c0
    f1.txt: other deleted -> r
   removing f1.txt
    f2.txt: remote created -> g
   getting f2.txt
   2 changesets found
   list of changesets:
   e31216eec445e44352c5f01588856059466a24c9
   2f2496ddf49d69b5ef23ad8cf9fb2e0e4faf0ac2
   bundle2-output-bundle: "HG20", (1 params) 1 parts total
-  bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
+  bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   saved backup bundle to $TESTTMP/issue4041/.hg/strip-backup/e31216eec445-15f7a814-backup.hg (glob)
   3 changesets found
   list of changesets:
   4c9fbe56a16f30c0d5dcc40ec1a97bbe3325209c
   19c888675e133ab5dff84516926a65672eaf04d9
   2a7f09cac94c7f4b73ebd5cd1a62d3b2e8e336bf
   bundle2-output-bundle: "HG20", 1 parts total
-  bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
+  bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   adding branch
   bundle2-input-bundle: with-transaction
-  bundle2-input-part: "changegroup" (params: 1 mandatory) supported
+  bundle2-input-part: "changegroup" (params: 1 mandatory 1 advisory) supported
   adding changesets
   add changeset 4c9fbe56a16f
   add changeset 19c888675e13
   add changeset 2a7f09cac94c
   adding manifests
   adding file changes
   adding f1.txt revisions
   added 2 changesets with 2 changes to 1 files
   bundle2-input-part: total payload size 1713
   bundle2-input-bundle: 0 parts total
   invalid branchheads cache (served): tip differs
   rebase completed
   updating the branch cache
   truncating cache/rbc-revs-v1 to 72
 
 Test minimization of merge conflicts
   $ hg up -q null
   $ echo a > a
   $ hg add a
   $ hg commit -q -m 'a'
   $ echo b >> a
   $ hg commit -q -m 'ab'
   $ hg bookmark ab
   $ hg up -q '.^'
   $ echo b >> a
   $ echo c >> a
   $ hg commit -q -m 'abc'
   $ hg rebase -s 7bc217434fc1 -d ab --keep
   rebasing 13:7bc217434fc1 "abc" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg diff
   diff -r 328e4ab1f7cc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	* (glob)
   @@ -1,2 +1,6 @@
    a
    b
   +<<<<<<< dest:   328e4ab1f7cc  ab - test: ab
   +=======
   +c
   +>>>>>>> source: 7bc217434fc1 - test: abc
   $ hg rebase --abort
   rebase aborted
   $ hg up -q -C 7bc217434fc1
   $ hg rebase -s . -d ab --keep -t internal:merge3
   rebasing 13:7bc217434fc1 "abc" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg diff
   diff -r 328e4ab1f7cc a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	* (glob)
   @@ -1,2 +1,8 @@
    a
   +<<<<<<< dest:   328e4ab1f7cc  ab - test: ab
    b
   +||||||| base
   +=======
   +b
   +c
   +>>>>>>> source: 7bc217434fc1 - test: abc

tests/test-shelve.t

@@ -1,1624 +1,1624 b''
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > mq =
   > shelve =
   > [defaults]
   > diff = --nodates --git
   > qnew = --date '0 0'
   > [shelve]
   > maxbackups = 2
   > EOF
 
   $ hg init repo
   $ cd repo
   $ mkdir a b
   $ echo a > a/a
   $ echo b > b/b
   $ echo c > c
   $ echo d > d
   $ echo x > x
   $ hg addremove -q
 
 shelve has a help message
   $ hg shelve -h
   hg shelve [OPTION]... [FILE]...
   
   save and set aside changes from the working directory
   
       Shelving takes files that "hg status" reports as not clean, saves the
       modifications to a bundle (a shelved change), and reverts the files so
       that their state in the working directory becomes clean.
   
       To restore these changes to the working directory, using "hg unshelve";
       this will work even if you switch to a different commit.
   
       When no files are specified, "hg shelve" saves all not-clean files. If
       specific files or directories are named, only changes to those files are
       shelved.
   
       In bare shelve(when no files are specified, without interactive, include
       and exclude option), shelving remembers information if the working
       directory was on newly created branch, in other words working directory
       was on different branch than its first parent. In this situation
       unshelving restores branch information to the working directory.
   
       Each shelved change has a name that makes it easier to find later. The
       name of a shelved change defaults to being based on the active bookmark,
       or if there is no active bookmark, the current named branch.  To specify a
       different name, use "--name".
   
       To see a list of existing shelved changes, use the "--list" option. For
       each shelved change, this will print its name, age, and description; use "
       --patch" or "--stat" for more details.
   
       To delete specific shelved changes, use "--delete". To delete all shelved
       changes, use "--cleanup".
   
   (use "hg help -e shelve" to show help for the shelve extension)
   
   options ([+] can be repeated):
   
    -A --addremove           mark new/missing files as added/removed before
                             shelving
    -u --unknown             store unknown files in the shelve
       --cleanup             delete all shelved changes
       --date DATE           shelve with the specified commit date
    -d --delete              delete the named shelved change(s)
    -e --edit                invoke editor on commit messages
    -l --list                list current shelves
    -m --message TEXT        use text as shelve message
    -n --name NAME           use the given name for the shelved commit
    -p --patch               show patch
    -i --interactive         interactive mode, only works while creating a shelve
       --stat                output diffstat-style summary of changes
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
       --mq                  operate on patch repository
   
   (some details hidden, use --verbose to show complete help)
 
 shelving in an empty repo should be possible
 (this tests also that editor is not invoked, if '--edit' is not
 specified)
 
   $ HGEDITOR=cat hg shelve
   shelved as default
   0 files updated, 0 files merged, 5 files removed, 0 files unresolved
 
   $ hg unshelve
   unshelving change 'default'
 
   $ hg commit -q -m 'initial commit'
 
   $ hg shelve
   nothing changed
   [1]
 
 make sure shelve files were backed up
 
   $ ls .hg/shelve-backup
   default.hg
   default.patch
 
 create an mq patch - shelving should work fine with a patch applied
 
   $ echo n > n
   $ hg add n
   $ hg commit n -m second
   $ hg qnew second.patch
 
 shelve a change that we will delete later
 
   $ echo a >> a/a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 set up some more complex changes to shelve
 
   $ echo a >> a/a
   $ hg mv b b.rename
   moving b/b to b.rename/b (glob)
   $ hg cp c c.copy
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
 
 prevent some foot-shooting
 
   $ hg shelve -n foo/bar
   abort: shelved change names may not contain slashes
   [255]
   $ hg shelve -n .baz
   abort: shelved change names may not start with '.'
   [255]
 
 the common case - no options or filenames
 
   $ hg shelve
   shelved as default-01
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -C
 
 ensure that our shelved changes exist
 
   $ hg shelve -l
   default-01      (*)* changes to: [mq]: second.patch (glob)
   default         (*)* changes to: [mq]: second.patch (glob)
 
   $ hg shelve -l -p default
   default         (*)* changes to: [mq]: second.patch (glob)
   
   diff --git a/a/a b/a/a
   --- a/a/a
   +++ b/a/a
   @@ -1,1 +1,2 @@
    a
   +a
 
   $ hg shelve --list --addremove
   abort: options '--list' and '--addremove' may not be used together
   [255]
 
 delete our older shelved change
 
   $ hg shelve -d default
   $ hg qfinish -a -q
 
 ensure shelve backups aren't overwritten
 
   $ ls .hg/shelve-backup/
   default-1.hg
   default-1.patch
   default.hg
   default.patch
 
 local edits should not prevent a shelved change from applying
 
   $ printf "z\na\n" > a/a
   $ hg unshelve --keep
   unshelving change 'default-01'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 4:32c69314e062 "changes to: [mq]: second.patch" (tip)
   merging a/a
 
   $ hg revert --all -q
   $ rm a/a.orig b.rename/b c.copy
 
 apply it and make sure our state is as expected
 
 (this also tests that same timestamp prevents backups from being
 removed, even though there are more than 'maxbackups' backups)
 
   $ f -t .hg/shelve-backup/default.hg
   .hg/shelve-backup/default.hg: file
   $ touch -t 200001010000 .hg/shelve-backup/default.hg
   $ f -t .hg/shelve-backup/default-1.hg
   .hg/shelve-backup/default-1.hg: file
   $ touch -t 200001010000 .hg/shelve-backup/default-1.hg
 
   $ hg unshelve
   unshelving change 'default-01'
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   $ hg shelve -l
 
 (both of default.hg and default-1.hg should be still kept, because it
 is difficult to decide actual order of them from same timestamp)
 
   $ ls .hg/shelve-backup/
   default-01.hg
   default-01.patch
   default-1.hg
   default-1.patch
   default.hg
   default.patch
 
   $ hg unshelve
   abort: no shelved changes to apply!
   [255]
   $ hg unshelve foo
   abort: shelved change 'foo' not found
   [255]
 
 named shelves, specific filenames, and "commit messages" should all work
 (this tests also that editor is invoked, if '--edit' is specified)
 
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   $ HGEDITOR=cat hg shelve -q -n wibble -m wat -e a
   wat
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: shelve@localhost
   HG: branch 'default'
   HG: changed a/a
 
 expect "a" to no longer be present, but status otherwise unchanged
 
   $ hg status -C
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
   $ hg shelve -l --stat
   wibble          (*)    wat (glob)
    a/a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
 
 and now "a/a" should reappear
 
   $ cd a
   $ hg unshelve -q wibble
   $ cd ..
   $ hg status -C
   M a/a
   A b.rename/b
     b/b
   A c.copy
     c
   R b/b
 
 ensure old shelve backups are being deleted automatically
 
   $ ls .hg/shelve-backup/
   default-01.hg
   default-01.patch
   wibble.hg
   wibble.patch
 
 cause unshelving to result in a merge with 'a' conflicting
 
   $ hg shelve -q
   $ echo c>>a/a
   $ hg commit -m second
   $ hg tip --template '{files}\n'
   a/a
 
 add an unrelated change that should be preserved
 
   $ mkdir foo
   $ echo foo > foo/foo
   $ hg add foo/foo
 
 force a conflicted merge to occur
 
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 5:32c69314e062 "changes to: [mq]: second.patch" (tip)
   merging a/a
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
 
 ensure that we have a merge with unresolved conflicts
 
   $ hg heads -q --template '{rev}\n'
   5
   4
   $ hg parents -q --template '{rev}\n'
   4
   5
   $ hg status
   M a/a
   M b.rename/b
   M c.copy
   R b/b
   ? a/a.orig
   $ hg diff
   diff --git a/a/a b/a/a
   --- a/a/a
   +++ b/a/a
   @@ -1,2 +1,6 @@
    a
   +<<<<<<< dest:   *  - shelve: pending changes temporary commit (glob)
    c
   +=======
   +a
   +>>>>>>> source: 32c69314e062 - shelve: changes to: [mq]: second.patch
   diff --git a/b/b b/b.rename/b
   rename from b/b
   rename to b.rename/b
   diff --git a/c b/c.copy
   copy from c
   copy to c.copy
   $ hg resolve -l
   U a/a
 
   $ hg shelve
   abort: unshelve already in progress
   (use 'hg unshelve --continue' or 'hg unshelve --abort')
   [255]
 
 abort the unshelve and be happy
 
   $ hg status
   M a/a
   M b.rename/b
   M c.copy
   R b/b
   ? a/a.orig
   $ hg unshelve -a
   rebase aborted
   unshelve of 'default' aborted
   $ hg heads -q
   3:2e69b451d1ea
   $ hg parents
   changeset:   3:2e69b451d1ea
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second
   
   $ hg resolve -l
   $ hg status
   A foo/foo
   ? a/a.orig
 
 try to continue with no unshelve underway
 
   $ hg unshelve -c
   abort: no unshelve in progress
   [255]
   $ hg status
   A foo/foo
   ? a/a.orig
 
 redo the unshelve to get a conflict
 
   $ hg unshelve -q
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
 
 attempt to continue
 
   $ hg unshelve -c
   abort: unresolved conflicts, can't continue
   (see 'hg resolve', then 'hg unshelve --continue')
   [255]
 
   $ hg revert -r . a/a
   $ hg resolve -m a/a
   (no more unresolved files)
   continue: hg unshelve --continue
 
   $ hg commit -m 'commit while unshelve in progress'
   abort: unshelve already in progress
   (use 'hg unshelve --continue' or 'hg unshelve --abort')
   [255]
 
   $ hg graft --continue
   abort: no graft in progress
   (continue: hg unshelve --continue)
   [255]
   $ hg unshelve -c
   rebasing 5:32c69314e062 "changes to: [mq]: second.patch" (tip)
   unshelve of 'default' complete
 
 ensure the repo is as we hope
 
   $ hg parents
   changeset:   3:2e69b451d1ea
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second
   
   $ hg heads -q
   3:2e69b451d1ea
 
   $ hg status -C
   A b.rename/b
     b/b
   A c.copy
     c
   A foo/foo
   R b/b
   ? a/a.orig
 
 there should be no shelves left
 
   $ hg shelve -l
 
 #if execbit
 
 ensure that metadata-only changes are shelved
 
   $ chmod +x a/a
   $ hg shelve -q -n execbit a/a
   $ hg status a/a
   $ hg unshelve -q execbit
   $ hg status a/a
   M a/a
   $ hg revert a/a
 
 #endif
 
 #if symlink
 
   $ rm a/a
   $ ln -s foo a/a
   $ hg shelve -q -n symlink a/a
   $ hg status a/a
   $ hg unshelve -q symlink
   $ hg status a/a
   M a/a
   $ hg revert a/a
 
 #endif
 
 set up another conflict between a commit and a shelved change
 
   $ hg revert -q -C -a
   $ rm a/a.orig b.rename/b c.copy
   $ echo a >> a/a
   $ hg shelve -q
   $ echo x >> a/a
   $ hg ci -m 'create conflict'
   $ hg add foo/foo
 
 if we resolve a conflict while unshelving, the unshelve should succeed
 
   $ hg unshelve --tool :merge-other --keep
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 6:2f694dd83a13 "changes to: second" (tip)
   merging a/a
   $ hg parents -q
   4:33f7f61e6c5e
   $ hg shelve -l
   default         (*)* changes to: second (glob)
   $ hg status
   M a/a
   A foo/foo
   $ cat a/a
   a
   c
   a
   $ cat > a/a << EOF
   > a
   > c
   > x
   > EOF
 
   $ HGMERGE=true hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 6:2f694dd83a13 "changes to: second" (tip)
   merging a/a
   note: rebase of 6:2f694dd83a13 created no changes to commit
   $ hg parents -q
   4:33f7f61e6c5e
   $ hg shelve -l
   $ hg status
   A foo/foo
   $ cat a/a
   a
   c
   x
 
 test keep and cleanup
 
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg shelve --list
   default         (*)* changes to: create conflict (glob)
   $ hg unshelve -k
   unshelving change 'default'
   $ hg shelve --list
   default         (*)* changes to: create conflict (glob)
   $ hg shelve --cleanup
   $ hg shelve --list
 
   $ hg shelve --cleanup --delete
   abort: options '--cleanup' and '--delete' may not be used together
   [255]
   $ hg shelve --cleanup --patch
   abort: options '--cleanup' and '--patch' may not be used together
   [255]
   $ hg shelve --cleanup --message MESSAGE
   abort: options '--cleanup' and '--message' may not be used together
   [255]
 
 test bookmarks
 
   $ hg bookmark test
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg unshelve
   unshelving change 'test'
   $ hg bookmark
    * test                      4:33f7f61e6c5e
 
 shelve should still work even if mq is disabled
 
   $ hg --config extensions.mq=! shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg --config extensions.mq=! shelve --list
   test            (*)* changes to: create conflict (glob)
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg --config extensions.mq=! unshelve
   unshelving change 'test'
   $ hg bookmark
    * test                      4:33f7f61e6c5e
 
 shelve should leave dirstate clean (issue4055)
 
   $ cd ..
   $ hg init shelverebase
   $ cd shelverebase
   $ printf 'x\ny\n' > x
   $ echo z > z
   $ hg commit -Aqm xy
   $ echo z >> x
   $ hg commit -Aqm z
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf 'a\nx\ny\nz\n' > x
   $ hg commit -Aqm xyz
   $ echo c >> z
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg rebase -d 1 --config extensions.rebase=
   rebasing 2:323bfa07f744 "xyz" (tip)
   merging x
   saved backup bundle to $TESTTMP/shelverebase/.hg/strip-backup/323bfa07f744-78114325-backup.hg (glob)
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 4:82a0d7d6ba61 "changes to: xyz" (tip)
   $ hg status
   M z
 
   $ cd ..
 
 shelve should only unshelve pending changes (issue4068)
 
   $ hg init onlypendingchanges
   $ cd onlypendingchanges
   $ touch a
   $ hg ci -Aqm a
   $ touch b
   $ hg ci -Aqm b
   $ hg up -q 0
   $ touch c
   $ hg ci -Aqm c
 
   $ touch d
   $ hg add d
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up -q 1
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 3:958bcbd1776e "changes to: c" (tip)
   $ hg status
   A d
 
 unshelve should work on an ancestor of the original commit
 
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 3:013284d9655e "changes to: b" (tip)
   $ hg status
   A d
 
 test bug 4073 we need to enable obsolete markers for it
 
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution=createmarkers
   > EOF
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugobsolete `hg --debug id -i -r 1`
   $ hg unshelve
   unshelving change 'default'
 
 unshelve should leave unknown files alone (issue4113)
 
   $ echo e > e
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   ? e
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   A d
   ? e
   $ cat e
   e
 
 unshelve should keep a copy of unknown files
 
   $ hg add e
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo z > e
   $ hg unshelve
   unshelving change 'default'
   $ cat e
   e
   $ cat e.orig
   z
 
 
 unshelve and conflicts with tracked and untracked files
 
  preparing:
 
   $ rm *.orig
   $ hg ci -qm 'commit stuff'
   $ hg phase -p null:
 
  no other changes - no merge:
 
   $ echo f > f
   $ hg add f
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo g > f
   $ hg unshelve
   unshelving change 'default'
   $ hg st
   A f
   ? f.orig
   $ cat f
   f
   $ cat f.orig
   g
 
  other uncommitted changes - merge:
 
   $ hg st
   A f
   ? f.orig
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G --template '{rev}  {desc|firstline}  {author}' -R bundle://.hg/shelved/default.hg -r 'bundle()'
   o  4  changes to: commit stuff  shelve@localhost
   |
   ~
   $ hg log -G --template '{rev}  {desc|firstline}  {author}'
   @  3  commit stuff  test
   |
   | o  2  c  test
   |/
   o  0  a  test
   
   $ mv f.orig f
   $ echo 1 > a
   $ hg unshelve --date '1073741824 0'
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 5:81152db69da7 "changes to: commit stuff" (tip)
   merging f
   warning: conflicts while merging f! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ hg log -G --template '{rev}  {desc|firstline}  {author}  {date|isodate}'
   @  5  changes to: commit stuff  shelve@localhost  1970-01-01 00:00 +0000
   |
   | @  4  pending changes temporary commit  shelve@localhost  2004-01-10 13:37 +0000
   |/
   o  3  commit stuff  test  1970-01-01 00:00 +0000
   |
   | o  2  c  test  1970-01-01 00:00 +0000
   |/
   o  0  a  test  1970-01-01 00:00 +0000
   
   $ hg st
   M f
   ? f.orig
   $ cat f
   <<<<<<< dest:   5f6b880e719b  - shelve: pending changes temporary commit
   g
   =======
   f
   >>>>>>> source: 81152db69da7 - shelve: changes to: commit stuff
   $ cat f.orig
   g
   $ hg unshelve --abort -t false
   tool option will be ignored
   rebase aborted
   unshelve of 'default' aborted
   $ hg st
   M a
   ? f.orig
   $ cat f.orig
   g
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 5:81152db69da7 "changes to: commit stuff" (tip)
   $ hg st
   M a
   A f
   ? f.orig
 
  other committed changes - merge:
 
   $ hg shelve f
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg ci a -m 'intermediate other change'
   $ mv f.orig f
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 5:81152db69da7 "changes to: commit stuff" (tip)
   merging f
   warning: conflicts while merging f! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ hg st
   M f
   ? f.orig
   $ cat f
   <<<<<<< dest:   *  - test: intermediate other change (glob)
   g
   =======
   f
   >>>>>>> source: 81152db69da7 - shelve: changes to: commit stuff
   $ cat f.orig
   g
   $ hg unshelve --abort
   rebase aborted
   unshelve of 'default' aborted
   $ hg st
   ? f.orig
   $ cat f.orig
   g
   $ hg shelve --delete default
 
 Recreate some conflict again
 
   $ cd ../repo
   $ hg up -C -r 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark test)
   $ echo y >> a/a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up test
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark test)
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 5:e42a7da90865 "changes to: second" (tip)
   merging a/a
   warning: conflicts while merging a/a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ hg bookmark
      test                      4:33f7f61e6c5e
 
 Test that resolving all conflicts in one direction (so that the rebase
 is a no-op), works (issue4398)
 
   $ hg revert -a -r .
   reverting a/a (glob)
   $ hg resolve -m a/a
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg unshelve -c
   rebasing 5:e42a7da90865 "changes to: second" (tip)
   note: rebase of 5:e42a7da90865 created no changes to commit
   unshelve of 'default' complete
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg diff
   $ hg status
   ? a/a.orig
   ? foo/foo
   $ hg summary
   parent: 4:33f7f61e6c5e tip
    create conflict
   branch: default
   bookmarks: *test
   commit: 2 unknown (clean)
   update: (current)
   phases: 5 draft
 
   $ hg shelve --delete --stat
   abort: options '--delete' and '--stat' may not be used together
   [255]
   $ hg shelve --delete --name NAME
   abort: options '--delete' and '--name' may not be used together
   [255]
 
 Test interactive shelve
   $ cat <<EOF >> $HGRCPATH
   > [ui]
   > interactive = true
   > EOF
   $ echo 'a' >> a/b
   $ cat a/a >> a/b
   $ echo 'x' >> a/b
   $ mv a/b a/a
   $ echo 'a' >> foo/foo
   $ hg st
   M a/a
   ? a/a.orig
   ? foo/foo
   $ cat a/a
   a
   a
   c
   x
   x
   $ cat foo/foo
   foo
   a
   $ hg shelve --interactive --config ui.interactive=false
   abort: running non-interactively
   [255]
   $ hg shelve --interactive << EOF
   > y
   > y
   > n
   > EOF
   diff --git a/a/a b/a/a
   2 hunks, 2 lines changed
   examine changes to 'a/a'? [Ynesfdaq?] y
   
   @@ -1,3 +1,4 @@
   +a
    a
    c
    x
   record change 1/2 to 'a/a'? [Ynesfdaq?] y
   
   @@ -1,3 +2,4 @@
    a
    c
    x
   +x
   record change 2/2 to 'a/a'? [Ynesfdaq?] n
   
   shelved as test
   merging a/a
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   $ cat a/a
   a
   c
   x
   x
   $ cat foo/foo
   foo
   a
   $ hg st
   M a/a
   ? foo/foo
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ hg unshelve
   unshelving change 'test'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 6:96a1354f65f6 "changes to: create conflict" (tip)
   merging a/a
   $ hg bookmark
    * test                      4:33f7f61e6c5e
   $ cat a/a
   a
   a
   c
   x
   x
 
 shelve --patch and shelve --stat should work with a single valid shelfname
 
   $ hg up --clean .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (leaving bookmark test)
   $ hg shelve --list
   $ echo 'patch a' > shelf-patch-a
   $ hg add shelf-patch-a
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'patch b' > shelf-patch-b
   $ hg add shelf-patch-b
   $ hg shelve
   shelved as default-01
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg shelve --patch default default-01
   abort: --patch expects a single shelf
   [255]
   $ hg shelve --stat default default-01
   abort: --stat expects a single shelf
   [255]
   $ hg shelve --patch default
   default         (*)* changes to: create conflict (glob)
   
   diff --git a/shelf-patch-a b/shelf-patch-a
   new file mode 100644
   --- /dev/null
   +++ b/shelf-patch-a
   @@ -0,0 +1,1 @@
   +patch a
   $ hg shelve --stat default
   default         (*)* changes to: create conflict (glob)
    shelf-patch-a |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ hg shelve --patch nonexistentshelf
   abort: cannot find shelf nonexistentshelf
   [255]
   $ hg shelve --stat nonexistentshelf
   abort: cannot find shelf nonexistentshelf
   [255]
 
   $ cd ..
 
 Shelve from general delta repo uses bundle2 on disk
 --------------------------------------------------
 
 no general delta
 
   $ hg clone --pull repo bundle1 --config format.usegeneraldelta=0
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 8 changes to 6 files
   updating to branch default
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd bundle1
   $ echo babar > jungle
   $ hg add jungle
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugbundle .hg/shelved/*.hg
   45993d65fe9dc3c6d8764b9c3b07fa831ee7d92d
   $ cd ..
 
 with general delta
 
   $ hg clone --pull repo bundle2 --config format.usegeneraldelta=1
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 8 changes to 6 files
   updating to branch default
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd bundle2
   $ echo babar > jungle
   $ hg add jungle
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg debugbundle .hg/shelved/*.hg
   Stream params: sortdict([('Compression', 'BZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       45993d65fe9dc3c6d8764b9c3b07fa831ee7d92d
   $ cd ..
 
 Test visibility of in-memory changes inside transaction to external hook
 ------------------------------------------------------------------------
 
   $ cd repo
 
   $ echo xxxx >> x
   $ hg commit -m "#5: changes to invoke rebase"
 
   $ cat > $TESTTMP/checkvisibility.sh <<EOF
   > echo "==== \$1:"
   > hg parents --template "VISIBLE {rev}:{node|short}\n"
   > # test that pending changes are hidden
   > unset HG_PENDING
   > hg parents --template "ACTUAL  {rev}:{node|short}\n"
   > echo "===="
   > EOF
 
   $ cat >> .hg/hgrc <<EOF
   > [defaults]
   > # to fix hash id of temporary revisions
   > unshelve = --date '0 0'
   > EOF
 
 "hg unshelve" at REV5 implies steps below:
 
 (1) commit changes in the working directory (REV6)
 (2) unbundle shelved revision (REV7)
 (3) rebase: merge REV7 into REV6 (REV6 => REV6, REV7)
 (4) rebase: commit merged revision (REV8)
 (5) rebase: update to REV6 (REV8 => REV6)
 (6) update to REV5 (REV6 => REV5)
 (7) abort transaction
 
 == test visibility to external preupdate hook
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility = sh $TESTTMP/checkvisibility.sh preupdate
   > EOF
 
   $ echo nnnn >> n
 
   $ sh $TESTTMP/checkvisibility.sh before-unshelving
   ==== before-unshelving:
   VISIBLE 5:703117a2acfb
   ACTUAL  5:703117a2acfb
   ====
 
   $ hg unshelve --keep default
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 7:206bf5d4f922 "changes to: create conflict" (tip)
   ==== preupdate:
   VISIBLE 6:66b86db80ee4
   ACTUAL  5:703117a2acfb
   ====
   ==== preupdate:
   VISIBLE 8:a0e04704317e
   ACTUAL  5:703117a2acfb
   ====
   ==== preupdate:
   VISIBLE 6:66b86db80ee4
   ACTUAL  5:703117a2acfb
   ====
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > preupdate.visibility =
   > EOF
 
   $ sh $TESTTMP/checkvisibility.sh after-unshelving
   ==== after-unshelving:
   VISIBLE 5:703117a2acfb
   ACTUAL  5:703117a2acfb
   ====
 
 == test visibility to external update hook
 
   $ hg update -q -C 5
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility = sh $TESTTMP/checkvisibility.sh update
   > EOF
 
   $ echo nnnn >> n
 
   $ sh $TESTTMP/checkvisibility.sh before-unshelving
   ==== before-unshelving:
   VISIBLE 5:703117a2acfb
   ACTUAL  5:703117a2acfb
   ====
 
   $ hg unshelve --keep default
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 7:206bf5d4f922 "changes to: create conflict" (tip)
   ==== update:
   VISIBLE 6:66b86db80ee4
   VISIBLE 7:206bf5d4f922
   ACTUAL  5:703117a2acfb
   ====
   ==== update:
   VISIBLE 6:66b86db80ee4
   ACTUAL  5:703117a2acfb
   ====
   ==== update:
   VISIBLE 5:703117a2acfb
   ACTUAL  5:703117a2acfb
   ====
 
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > update.visibility =
   > EOF
 
   $ sh $TESTTMP/checkvisibility.sh after-unshelving
   ==== after-unshelving:
   VISIBLE 5:703117a2acfb
   ACTUAL  5:703117a2acfb
   ====
 
   $ cd ..
 
 test .orig files go where the user wants them to
 ---------------------------------------------------------------
   $ hg init salvage
   $ cd salvage
   $ echo 'content' > root
   $ hg commit -A -m 'root' -q
   $ echo '' > root
   $ hg shelve -q
   $ echo 'contADDent' > root
   $ hg unshelve -q --config 'ui.origbackuppath=.hg/origbackups'
   warning: conflicts while merging root! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ ls .hg/origbackups
   root.orig
   $ rm -rf .hg/origbackups
 
 test Abort unshelve always gets user out of the unshelved state
 ---------------------------------------------------------------
 Wreak havoc on the unshelve process
   $ rm .hg/unshelverebasestate
   $ hg unshelve --abort
   unshelve of 'default' aborted
   abort: (No such file or directory|The system cannot find the file specified) (re)
   [255]
 Can the user leave the current state?
   $ hg up -C .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Try again but with a corrupted shelve state file
   $ hg strip -r 2 -r 1 -q
   $ hg up -r 0 -q
   $ echo '' > root
   $ hg shelve -q
   $ echo 'contADDent' > root
   $ hg unshelve -q
   warning: conflicts while merging root! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ sed 's/ae8c668541e8/123456789012/' .hg/shelvedstate > ../corrupt-shelvedstate
   $ mv ../corrupt-shelvedstate .hg/histedit-state
   $ hg unshelve --abort 2>&1 | grep 'rebase aborted'
   rebase aborted
   $ hg up -C .
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..
 
 Keep active bookmark while (un)shelving even on shared repo (issue4940)
 -----------------------------------------------------------------------
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > share =
   > EOF
 
   $ hg bookmarks -R repo
      test                      4:33f7f61e6c5e
   $ hg share -B repo share
   updating working directory
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd share
 
   $ hg bookmarks
      test                      4:33f7f61e6c5e
   $ hg bookmarks foo
   $ hg bookmarks
    * foo                       5:703117a2acfb
      test                      4:33f7f61e6c5e
   $ echo x >> x
   $ hg shelve
   shelved as foo
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg bookmarks
    * foo                       5:703117a2acfb
      test                      4:33f7f61e6c5e
 
   $ hg unshelve
   unshelving change 'foo'
   $ hg bookmarks
    * foo                       5:703117a2acfb
      test                      4:33f7f61e6c5e
 
   $ cd ..
 
 Shelve and unshelve unknown files. For the purposes of unshelve, a shelved
 unknown file is the same as a shelved added file, except that it will be in
 unknown state after unshelve if and only if it was either absent or unknown
 before the unshelve operation.
 
   $ hg init unknowns
   $ cd unknowns
 
 The simplest case is if I simply have an unknown file that I shelve and unshelve
 
   $ echo unknown > unknown
   $ hg status
   ? unknown
   $ hg shelve --unknown
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   ? unknown
   $ rm unknown
 
 If I shelve, add the file, and unshelve, does it stay added?
 
   $ echo unknown > unknown
   $ hg shelve -u
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ touch unknown
   $ hg add unknown
   $ hg status
   A unknown
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 1:098df96e7410 "(changes in empty repository)" (tip)
   merging unknown
   $ hg status
   A unknown
   $ hg forget unknown
   $ rm unknown
 
 And if I shelve, commit, then unshelve, does it become modified?
 
   $ echo unknown > unknown
   $ hg shelve -u
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg status
   $ touch unknown
   $ hg add unknown
   $ hg commit -qm "Add unknown"
   $ hg status
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 1:098df96e7410 "(changes in empty repository)" (tip)
   merging unknown
   $ hg status
   M unknown
   $ hg remove --force unknown
   $ hg commit -qm "Remove unknown"
 
   $ cd ..
 
 We expects that non-bare shelve keeps newly created branch in
 working directory.
 
   $ hg init shelve-preserve-new-branch
   $ cd shelve-preserve-new-branch
   $ echo "a" >> a
   $ hg add a
   $ echo "b" >> b
   $ hg add b
   $ hg commit -m "ab"
   $ echo "aa" >> a
   $ echo "bb" >> b
   $ hg branch new-branch
   marked working directory as branch new-branch
   (branches are permanent and global, did you want a bookmark?)
   $ hg status
   M a
   M b
   $ hg branch
   new-branch
   $ hg shelve a
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   M b
   $ touch "c" >> c
   $ hg add c
   $ hg status
   M b
   A c
   $ hg shelve --exclude c
   shelved as default-01
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   A c
   $ hg shelve --include c
   shelved as default-02
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch
   new-branch
   $ hg status
   $ echo "d" >> d
   $ hg add d
   $ hg status
   A d
 
 We expect that bare-shelve will not keep branch in current working directory.
 
   $ hg shelve
   shelved as default-03
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch
   default
 
 When i shelve commit on newly created branch i expect
 that after unshelve newly created branch will be preserved.
 
   $ hg init shelve_on_new_branch_simple
   $ cd shelve_on_new_branch_simple
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "bbb" >> b
   $ hg status
   ? b
   $ hg unshelve
   unshelving change 'default'
   marked working directory as branch test
   $ hg status
   M a
   ? b
   $ hg branch
   test
 
 When i shelve commit on newly created branch, make
 some changes, unshelve it and running into merge
 conflicts i expect that after fixing them and
 running unshelve --continue newly created branch
 will be preserved.
 
   $ hg init shelve_on_new_branch_conflict
   $ cd shelve_on_new_branch_conflict
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "ccc" >> a
   $ hg status
   M a
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 2:425c97ef07f3 "changes to: a" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ echo "aaabbbccc" > a
   $ rm a.orig
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg unshelve --continue
   rebasing 2:425c97ef07f3 "changes to: a" (tip)
   marked working directory as branch test
   unshelve of 'default' complete
   $ cat a
   aaabbbccc
   $ hg status
   M a
   $ hg branch
   test
   $ hg commit -m "test-commit"
 
 When i shelve on test branch, update to default branch
 and unshelve i expect that it will not preserve previous
 test branch.
 
   $ echo "xxx" > b
   $ hg add b
   $ hg shelve
   shelved as test
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg update -r default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg unshelve
   unshelving change 'test'
   rebasing shelved changes
   rebasing 2:357525f34729 "changes to: test-commit" (tip)
   $ hg status
   A b
   $ hg branch
   default
 
 When i unshelve resulting in merge conflicts and makes saved
 file shelvedstate looks like in previous versions in
 mercurial(without restore branch information in 7th line) i
 expect that after resolving conflicts and succesfully
 running 'shelve --continue' the branch information won't be
 restored and branch will be unchanged.
 
 shelve on new branch, conflict with previous shelvedstate
 
   $ hg init conflict
   $ cd conflict
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   default
   $ echo "ccc" >> a
   $ hg status
   M a
   $ hg unshelve
   unshelving change 'default'
   temporarily committing pending changes (restore with 'hg unshelve --abort')
   rebasing shelved changes
   rebasing 2:425c97ef07f3 "changes to: a" (tip)
   merging a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
 
 Removing restore branch information from shelvedstate file(making it looks like
 in previous versions) and running unshelve --continue
 
   $ head -n 6 < .hg/shelvedstate > .hg/shelvedstate_oldformat
   $ rm .hg/shelvedstate
   $ mv .hg/shelvedstate_oldformat .hg/shelvedstate
 
   $ echo "aaabbbccc" > a
   $ rm a.orig
   $ hg resolve --mark a
   (no more unresolved files)
   continue: hg unshelve --continue
   $ hg unshelve --continue
   rebasing 2:425c97ef07f3 "changes to: a" (tip)
   unshelve of 'default' complete
   $ cat a
   aaabbbccc
   $ hg status
   M a
   $ hg branch
   default
 
 On non bare shelve the branch information shouldn't be restored
 
   $ hg init bare_shelve_on_new_branch
   $ cd bare_shelve_on_new_branch
   $ echo "aaa" >> a
   $ hg commit -A -m "a"
   adding a
   $ hg branch
   default
   $ hg branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> a
   $ hg status
   M a
   $ hg shelve a
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg branch
   test
   $ hg branch default
   marked working directory as branch default
   (branches are permanent and global, did you want a bookmark?)
   $ echo "bbb" >> b
   $ hg status
   ? b
   $ hg unshelve
   unshelving change 'default'
   $ hg status
   M a
   ? b
   $ hg branch
   default
   $ cd ..
 
 Prepare unshleve with a corrupted shelvedstate
   $ hg init r1 && cd r1
   $ echo text1 > file && hg add file
   $ hg shelve
   shelved as default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo text2 > file && hg ci -Am text1
   adding file
   $ hg unshelve
   unshelving change 'default'
   rebasing shelved changes
   rebasing 1:396ea74229f9 "(changes in empty repository)" (tip)
   merging file
   warning: conflicts while merging file! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg unshelve --continue')
   [1]
   $ echo somethingsomething > .hg/shelvedstate
 
 Unshelve --continue fails with appropriate message if shelvedstate is corrupted
   $ hg unshelve --continue
   abort: corrupted shelved state file
   (please run hg unshelve --abort to abort unshelve operation)
   [255]
 
 Unshelve --abort works with a corrupted shelvedstate
   $ hg unshelve --abort
   could not read shelved state file, your working copy may be in an unexpected state
   please update to some commit
 
 Unshelve --abort fails with appropriate message if there's no unshelve in
 progress
   $ hg unshelve --abort
   abort: no unshelve in progress
   [255]
   $ cd ..

tests/test-strip.t

@@ -1,898 +1,898 b''
   $ echo "[format]" >> $HGRCPATH
   $ echo "usegeneraldelta=yes" >> $HGRCPATH
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "strip=" >> $HGRCPATH
 
   $ restore() {
   >     hg unbundle -q .hg/strip-backup/*
   >     rm .hg/strip-backup/*
   > }
   $ teststrip() {
   >     hg up -C $1
   >     echo % before update $1, strip $2
   >     hg parents
   >     hg --traceback strip $2
   >     echo % after update $1, strip $2
   >     hg parents
   >     restore
   > }
 
   $ hg init test
   $ cd test
 
   $ echo foo > bar
   $ hg ci -Ama
   adding bar
 
   $ echo more >> bar
   $ hg ci -Amb
 
   $ echo blah >> bar
   $ hg ci -Amc
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah >> bar
   $ hg ci -Amd
   created new head
 
   $ echo final >> bar
   $ hg ci -Ame
 
   $ hg log
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   3:65bd5f99a4a3
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   2:264128213d29
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 
   $ teststrip 4 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 4
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 4
   changeset:   3:65bd5f99a4a3
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   $ teststrip 4 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 3
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 3
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ teststrip 1 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 1, strip 4
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 1, strip 4
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ teststrip 4 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 2
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 2
   changeset:   3:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   $ teststrip 4 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 1
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 1
   changeset:   0:9ab35a2d17cb
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ teststrip null 4
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   % before update null, strip 4
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update null, strip 4
 
   $ hg log
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   3:443431ffac4f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg up -C 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg parents
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
 
   $ hg --traceback strip 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/264128213d29-0b39d6bf-backup.hg (glob)
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ hg debugbundle .hg/strip-backup/*
   Stream params: sortdict([('Compression', 'BZ')])
-  changegroup -- "sortdict([('version', '02')])"
+  changegroup -- "sortdict([('version', '02'), ('nbchanges', '1')])"
       264128213d290d868c54642d13aeaa3675551a78
   $ hg pull .hg/strip-backup/*
   pulling from .hg/strip-backup/264128213d29-0b39d6bf-backup.hg
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (+1 heads)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ rm .hg/strip-backup/*
   $ hg log --graph
   o  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 before strip of merge parent
 
   $ hg parents
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   $ hg strip 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 after strip of merge parent
 
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ restore
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other heads for branch "default"
   $ hg log -G
   @  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 is parent of 3, only one strip should happen
 
   $ hg strip "roots(2)" 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   @  changeset:   2:264128213d29
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
   $ hg log -G
   o  changeset:   4:443431ffac4f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:65bd5f99a4a3
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   | @  changeset:   2:264128213d29
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 different branches: 2 strips
 
   $ hg strip 2 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   o  changeset:   2:65bd5f99a4a3
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
 
 2 different branches and a common ancestor: 1 strip
 
   $ hg strip 1 "2|4"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ restore
 
 verify fncache is kept up-to-date
 
   $ touch a
   $ hg ci -qAm a
   $ cat .hg/store/fncache | sort
   data/a.i
   data/bar.i
   $ hg strip tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ cat .hg/store/fncache
   data/bar.i
 
 stripping an empty revset
 
   $ hg strip "1 and not 1"
   abort: empty revision set
   [255]
 
 remove branchy history for qimport tests
 
   $ hg strip 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 
 strip of applied mq should cleanup status file
 
   $ echo "mq=" >> $HGRCPATH
   $ hg up -C 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo fooagain >> bar
   $ hg ci -mf
   $ hg qimport -r tip:2
 
 applied patches before strip
 
   $ hg qapplied
   d
   e
   f
 
 stripping revision in queue
 
   $ hg strip 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping rev in queue
 
   $ hg qapplied
   d
 
 stripping ancestor of queue
 
   $ hg strip 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping ancestor of queue
 
   $ hg qapplied
 
 Verify strip protects against stripping wc parent when there are uncommitted mods
 
   $ echo b > b
   $ echo bb > bar
   $ hg add b
   $ hg ci -m 'b'
   $ hg log --graph
   @  changeset:   1:76dcf9fab855
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > bar
   $ hg up -t false
   merging bar
   merging bar failed!
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg sum
   parent: 1:76dcf9fab855 tip
    b
   branch: default
   commit: 1 modified, 1 unknown, 1 unresolved
   update: (current)
   phases: 2 draft
   mq:     3 unapplied
 
   $ echo c > b
   $ hg strip tip
   abort: local changes found
   [255]
   $ hg strip tip --keep
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log --graph
   @  changeset:   0:9ab35a2d17cb
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg status
   M bar
   ? b
   ? bar.orig
 
   $ rm bar.orig
   $ hg sum
   parent: 0:9ab35a2d17cb tip
    a
   branch: default
   commit: 1 modified, 1 unknown
   update: (current)
   phases: 1 draft
   mq:     3 unapplied
 
 Strip adds, removes, modifies with --keep
 
   $ touch b
   $ hg add b
   $ hg commit -mb
   $ touch c
 
 ... with a clean working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   ! bar
   ? c
 
 ... with a dirty working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ echo b > b
   $ echo d > d
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   M b
   ! bar
   ? c
   ? d
 
 ... after updating the dirstate
   $ hg add c
   $ hg commit -mc
   $ hg rm c
   $ hg commit -mc
   $ hg strip --keep '.^' -q
   $ cd ..
 
 stripping many nodes on a complex graph (issue3299)
 
   $ hg init issue3299
   $ cd issue3299
   $ hg debugbuilddag '@a.:a@b.:b.:x<a@a.:a<b@b.:b<a@a.:a'
   $ hg strip 'not ancestors(x)'
   saved backup bundle to $TESTTMP/issue3299/.hg/strip-backup/*-backup.hg (glob)
 
 test hg strip -B bookmark
 
   $ cd ..
   $ hg init bookmarks
   $ cd bookmarks
   $ hg debugbuilddag '..<2.*1/2:m<2+3:c<m+3:a<2.:b<m+2:d<2.:e<m+1:f'
   $ hg bookmark -r 'a' 'todelete'
   $ hg bookmark -r 'b' 'B'
   $ hg bookmark -r 'b' 'nostrip'
   $ hg bookmark -r 'c' 'delete'
   $ hg bookmark -r 'd' 'multipledelete1'
   $ hg bookmark -r 'e' 'multipledelete2'
   $ hg bookmark -r 'f' 'singlenode1'
   $ hg bookmark -r 'f' 'singlenode2'
   $ hg up -C todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark todelete)
   $ hg strip -B nostrip
   bookmark 'nostrip' deleted
   abort: empty revision set
   [255]
   $ hg strip -B todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'todelete' deleted
   $ hg id -ir dcbb326fdec2
   abort: unknown revision 'dcbb326fdec2'!
   [255]
   $ hg id -ir d62d843c9a01
   d62d843c9a01
   $ hg bookmarks
      B                         9:ff43616e5d0f
      delete                    6:2702dd0c91e7
      multipledelete1           11:e46a4836065c
      multipledelete2           12:b4594d867745
      singlenode1               13:43227190fef8
      singlenode2               13:43227190fef8
   $ hg strip -B multipledelete1 -B multipledelete2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/e46a4836065c-89ec65c2-backup.hg (glob)
   bookmark 'multipledelete1' deleted
   bookmark 'multipledelete2' deleted
   $ hg id -ir e46a4836065c
   abort: unknown revision 'e46a4836065c'!
   [255]
   $ hg id -ir b4594d867745
   abort: unknown revision 'b4594d867745'!
   [255]
   $ hg strip -B singlenode1 -B singlenode2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/43227190fef8-8da858f2-backup.hg (glob)
   bookmark 'singlenode1' deleted
   bookmark 'singlenode2' deleted
   $ hg id -ir 43227190fef8
   abort: unknown revision '43227190fef8'!
   [255]
   $ hg strip -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B unknownbookmark1 -B unknownbookmark2
   abort: bookmark 'unknownbookmark1,unknownbookmark2' not found
   [255]
   $ hg strip -B delete -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B delete
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'delete' deleted
   $ hg id -ir 6:2702dd0c91e7
   abort: unknown revision '2702dd0c91e7'!
   [255]
   $ hg update B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark B)
   $ echo a > a
   $ hg add a
   $ hg strip -B B
   abort: local changes found
   [255]
   $ hg bookmarks
    * B                         6:ff43616e5d0f
 
 Make sure no one adds back a -b option:
 
   $ hg strip -b tip
   hg strip: option -b not recognized
   hg strip [-k] [-f] [-B bookmark] [-r] REV...
   
   strip changesets and all their descendants from the repository
   
   (use "hg help -e strip" to show help for the strip extension)
   
   options ([+] can be repeated):
   
    -r --rev REV [+]        strip specified revision (optional, can specify
                            revisions without this option)
    -f --force              force removal of changesets, discard uncommitted
                            changes (no backup)
       --no-backup          no backups
    -k --keep               do not modify working directory during strip
    -B --bookmark VALUE [+] remove revs only reachable from given bookmark
       --mq                 operate on patch repository
   
   (use "hg strip -h" to show more help)
   [255]
 
   $ cd ..
 
 Verify bundles don't get overwritten:
 
   $ hg init doublebundle
   $ cd doublebundle
   $ touch a
   $ hg commit -Aqm a
   $ touch b
   $ hg commit -Aqm b
   $ hg strip -r 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-e68910bd-backup.hg (glob)
   $ ls .hg/strip-backup
   3903775176ed-e68910bd-backup.hg
   $ hg pull -q -r 3903775176ed .hg/strip-backup/3903775176ed-e68910bd-backup.hg
   $ hg strip -r 0
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-54390173-backup.hg (glob)
   $ ls .hg/strip-backup
   3903775176ed-54390173-backup.hg
   3903775176ed-e68910bd-backup.hg
   $ cd ..
 
 Test that we only bundle the stripped changesets (issue4736)
 ------------------------------------------------------------
 
 initialization (previous repo is empty anyway)
 
   $ hg init issue4736
   $ cd issue4736
   $ echo a > a
   $ hg add a
   $ hg commit -m commitA
   $ echo b > b
   $ hg add b
   $ hg commit -m commitB
   $ echo c > c
   $ hg add c
   $ hg commit -m commitC
   $ hg up 'desc(commitB)'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg add d
   $ hg commit -m commitD
   created new head
   $ hg up 'desc(commitC)'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc(commitD)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'mergeCD'
   $ hg log -G
   @    changeset:   4:d8db9d137221
   |\   tag:         tip
   | |  parent:      2:5c51d8d6557d
   | |  parent:      3:6625a5168474
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     mergeCD
   | |
   | o  changeset:   3:6625a5168474
   | |  parent:      1:eca11cf91c71
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     commitD
   | |
   o |  changeset:   2:5c51d8d6557d
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     commitC
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 Check bundle behavior:
 
   $ hg bundle -r 'desc(mergeCD)' --base 'desc(commitC)' ../issue4736.hg
   2 changesets found
   $ hg log -r 'bundle()' -R ../issue4736.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 
 check strip behavior
 
   $ hg --config extensions.strip= strip 'desc(commitD)' --debug
   resolving manifests
    branchmerge: False, force: True, partial: False
    ancestor: d8db9d137221+, local: d8db9d137221+, remote: eca11cf91c71
    c: other deleted -> r
   removing c
    d: other deleted -> r
   removing d
   starting 4 threads for background file closing (?)
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   2 changesets found
   list of changesets:
   6625a516847449b6f0fa3737b9ba56e9f0f3032c
   d8db9d1372214336d2b5570f20ee468d2c72fa8b
   bundle2-output-bundle: "HG20", (1 params) 1 parts total
-  bundle2-output-part: "changegroup" (params: 1 mandatory) streamed payload
+  bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/6625a5168474-345bb43d-backup.hg (glob)
   invalid branchheads cache (served): tip differs
   truncating cache/rbc-revs-v1 to 24
   $ hg log -G
   o  changeset:   2:5c51d8d6557d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitC
   |
   @  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 strip backup content
 
   $ hg log -r 'bundle()' -R .hg/strip-backup/6625a5168474-*-backup.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 Check that the phase cache is properly invalidated after a strip with bookmark.
 
   $ cat > ../stripstalephasecache.py << EOF
   > from mercurial import extensions, localrepo
   > def transactioncallback(orig, repo, desc, *args, **kwargs):
   >     def test(transaction):
   >         # observe cache inconsistency
   >         try:
   >             [repo.changelog.node(r) for r in repo.revs("not public()")]
   >         except IndexError:
   >             repo.ui.status("Index error!\n")
   >     transaction = orig(repo, desc, *args, **kwargs)
   >     # warm up the phase cache
   >     list(repo.revs("not public()"))
   >     if desc != 'strip':
   >          transaction.addpostclose("phase invalidation test", test)
   >     return transaction
   > def extsetup(ui):
   >     extensions.wrapfunction(localrepo.localrepository, "transaction",
   >                             transactioncallback)
   > EOF
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo k > k
   $ hg add k
   $ hg commit -m commitK
   $ echo l > l
   $ hg add l
   $ hg commit -m commitL
   $ hg book -r tip blah
   $ hg strip ".^" --config extensions.crash=$TESTTMP/stripstalephasecache.py
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/8f0b4384875c-4fa10deb-backup.hg (glob)
   $ hg up -C 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Error during post-close callback of the strip transaction
 (They should be gracefully handled and reported)
 
   $ cat > ../crashstrip.py << EOF
   > from mercurial import error
   > def reposetup(ui, repo):
   >     class crashstriprepo(repo.__class__):
   >         def transaction(self, desc, *args, **kwargs):
   >             tr = super(crashstriprepo, self).transaction(self, desc, *args, **kwargs)
   >             if desc == 'strip':
   >                 def crash(tra): raise error.Abort('boom')
   >                 tr.addpostclose('crash', crash)
   >             return tr
   >     repo.__class__ = crashstriprepo
   > EOF
   $ hg strip tip --config extensions.crash=$TESTTMP/crashstrip.py
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg (glob)
   strip failed, full bundle stored in '$TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg' (glob)
   abort: boom
   [255]