transaction: quietly rollback if no other changes than temporary files

If no actual change have been made, we don't really need to roll them back. We
only have to cleanup some temporary files and it seems reasonable to do that
quietly.

This will help us to use the transaction in wider context¹ without impacting the
user experience.

[1] as in Python context managers that lives longer.

mercurial/transaction.py

@@ -1,786 +1,795 b''
 # transaction.py - simple journaling scheme for mercurial
 #
 # This transaction scheme is intended to gracefully handle program
 # errors and interruptions. More serious failures like system crashes
 # can be recovered with an fsck-like tool. As the whole repository is
 # effectively log-structured, this should amount to simply truncating
 # anything that isn't referenced in the changelog.
 #
 # Copyright 2005, 2006 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from .i18n import _
 from . import (
     error,
     pycompat,
     util,
 )
 from .utils import stringutil
 
 version = 2
 
 GEN_GROUP_ALL = b'all'
 GEN_GROUP_PRE_FINALIZE = b'prefinalize'
 GEN_GROUP_POST_FINALIZE = b'postfinalize'
 
 
 def active(func):
     def _active(self, *args, **kwds):
         if self._count == 0:
             raise error.ProgrammingError(
                 b'cannot use transaction when it is already committed/aborted'
             )
         return func(self, *args, **kwds)
 
     return _active
 
 
 def _playback(
     journal,
     report,
     opener,
     vfsmap,
     entries,
     backupentries,
     unlink=True,
     checkambigfiles=None,
 ):
     for f, o in sorted(dict(entries).items()):
         if o or not unlink:
             checkambig = checkambigfiles and (f, b'') in checkambigfiles
             try:
                 fp = opener(f, b'a', checkambig=checkambig)
                 if fp.tell() < o:
                     raise error.Abort(
                         _(
                             b"attempted to truncate %s to %d bytes, but it was "
                             b"already %d bytes\n"
                         )
                         % (f, o, fp.tell())
                     )
                 fp.truncate(o)
                 fp.close()
             except IOError:
                 report(_(b"failed to truncate %s\n") % f)
                 raise
         else:
             try:
                 opener.unlink(f)
             except FileNotFoundError:
                 pass
 
     backupfiles = []
     for l, f, b, c in backupentries:
         if l not in vfsmap and c:
             report(b"couldn't handle %s: unknown cache location %s\n" % (b, l))
         vfs = vfsmap[l]
         try:
             if f and b:
                 filepath = vfs.join(f)
                 backuppath = vfs.join(b)
                 checkambig = checkambigfiles and (f, l) in checkambigfiles
                 try:
                     util.copyfile(backuppath, filepath, checkambig=checkambig)
                     backupfiles.append(b)
                 except IOError as exc:
                     e_msg = stringutil.forcebytestr(exc)
                     report(_(b"failed to recover %s (%s)\n") % (f, e_msg))
             else:
                 target = f or b
                 try:
                     vfs.unlink(target)
                 except FileNotFoundError:
                     pass
         except (IOError, OSError, error.Abort):
             if not c:
                 raise
 
     backuppath = b"%s.backupfiles" % journal
     if opener.exists(backuppath):
         opener.unlink(backuppath)
     opener.unlink(journal)
     try:
         for f in backupfiles:
             if opener.exists(f):
                 opener.unlink(f)
     except (IOError, OSError, error.Abort):
         # only pure backup file remains, it is sage to ignore any error
         pass
 
 
 class transaction(util.transactional):
     def __init__(
         self,
         report,
         opener,
         vfsmap,
         journalname,
         undoname=None,
         after=None,
         createmode=None,
         validator=None,
         releasefn=None,
         checkambigfiles=None,
         name='<unnamed>',
     ):
         """Begin a new transaction
 
         Begins a new transaction that allows rolling back writes in the event of
         an exception.
 
         * `after`: called after the transaction has been committed
         * `createmode`: the mode of the journal file that will be created
         * `releasefn`: called after releasing (with transaction and result)
 
         `checkambigfiles` is a set of (path, vfs-location) tuples,
         which determine whether file stat ambiguity should be avoided
         for corresponded files.
         """
         self._count = 1
         self._usages = 1
         self._report = report
         # a vfs to the store content
         self._opener = opener
         # a map to access file in various {location -> vfs}
         vfsmap = vfsmap.copy()
         vfsmap[b''] = opener  # set default value
         self._vfsmap = vfsmap
         self._after = after
         self._offsetmap = {}
         self._newfiles = set()
         self._journal = journalname
         self._undoname = undoname
         self._queue = []
         # A callback to do something just after releasing transaction.
         if releasefn is None:
             releasefn = lambda tr, success: None
         self._releasefn = releasefn
 
         self._checkambigfiles = set()
         if checkambigfiles:
             self._checkambigfiles.update(checkambigfiles)
 
         self._names = [name]
 
         # A dict dedicated to precisely tracking the changes introduced in the
         # transaction.
         self.changes = {}
 
         # a dict of arguments to be passed to hooks
         self.hookargs = {}
         self._file = opener.open(self._journal, b"w+")
 
         # a list of ('location', 'path', 'backuppath', cache) entries.
         # - if 'backuppath' is empty, no file existed at backup time
         # - if 'path' is empty, this is a temporary transaction file
         # - if 'location' is not empty, the path is outside main opener reach.
         #   use 'location' value as a key in a vfsmap to find the right 'vfs'
         # (cache is currently unused)
         self._backupentries = []
         self._backupmap = {}
         self._backupjournal = b"%s.backupfiles" % self._journal
         self._backupsfile = opener.open(self._backupjournal, b'w')
         self._backupsfile.write(b'%d\n' % version)
 
         if createmode is not None:
             opener.chmod(self._journal, createmode & 0o666)
             opener.chmod(self._backupjournal, createmode & 0o666)
 
         # hold file generations to be performed on commit
         self._filegenerators = {}
         # hold callback to write pending data for hooks
         self._pendingcallback = {}
         # True is any pending data have been written ever
         self._anypending = False
         # holds callback to call when writing the transaction
         self._finalizecallback = {}
         # holds callback to call when validating the transaction
         # should raise exception if anything is wrong
         self._validatecallback = {}
         if validator is not None:
             self._validatecallback[b'001-userhooks'] = validator
         # hold callback for post transaction close
         self._postclosecallback = {}
         # holds callbacks to call during abort
         self._abortcallback = {}
 
     def __repr__(self):
         name = '/'.join(self._names)
         return '<transaction name=%s, count=%d, usages=%d>' % (
             name,
             self._count,
             self._usages,
         )
 
     def __del__(self):
         if self._journal:
             self._abort()
 
     @property
     def finalized(self):
         return self._finalizecallback is None
 
     @active
     def startgroup(self):
         """delay registration of file entry
 
         This is used by strip to delay vision of strip offset. The transaction
         sees either none or all of the strip actions to be done."""
         self._queue.append([])
 
     @active
     def endgroup(self):
         """apply delayed registration of file entry.
 
         This is used by strip to delay vision of strip offset. The transaction
         sees either none or all of the strip actions to be done."""
         q = self._queue.pop()
         for f, o in q:
             self._addentry(f, o)
 
     @active
     def add(self, file, offset):
         """record the state of an append-only file before update"""
         if (
             file in self._newfiles
             or file in self._offsetmap
             or file in self._backupmap
         ):
             return
         if self._queue:
             self._queue[-1].append((file, offset))
             return
 
         self._addentry(file, offset)
 
     def _addentry(self, file, offset):
         """add a append-only entry to memory and on-disk state"""
         if (
             file in self._newfiles
             or file in self._offsetmap
             or file in self._backupmap
         ):
             return
         if offset:
             self._offsetmap[file] = offset
         else:
             self._newfiles.add(file)
         # add enough data to the journal to do the truncate
         self._file.write(b"%s\0%d\n" % (file, offset))
         self._file.flush()
 
     @active
     def addbackup(self, file, hardlink=True, location=b''):
         """Adds a backup of the file to the transaction
 
         Calling addbackup() creates a hardlink backup of the specified file
         that is used to recover the file in the event of the transaction
         aborting.
 
         * `file`: the file path, relative to .hg/store
         * `hardlink`: use a hardlink to quickly create the backup
         """
         if self._queue:
             msg = b'cannot use transaction.addbackup inside "group"'
             raise error.ProgrammingError(msg)
 
         if (
             file in self._newfiles
             or file in self._offsetmap
             or file in self._backupmap
         ):
             return
         vfs = self._vfsmap[location]
         dirname, filename = vfs.split(file)
         backupfilename = b"%s.backup.%s" % (self._journal, filename)
         backupfile = vfs.reljoin(dirname, backupfilename)
         if vfs.exists(file):
             filepath = vfs.join(file)
             backuppath = vfs.join(backupfile)
             util.copyfile(filepath, backuppath, hardlink=hardlink)
         else:
             backupfile = b''
 
         self._addbackupentry((location, file, backupfile, False))
 
     def _addbackupentry(self, entry):
         """register a new backup entry and write it to disk"""
         self._backupentries.append(entry)
         self._backupmap[entry[1]] = len(self._backupentries) - 1
         self._backupsfile.write(b"%s\0%s\0%s\0%d\n" % entry)
         self._backupsfile.flush()
 
     @active
     def registertmp(self, tmpfile, location=b''):
         """register a temporary transaction file
 
         Such files will be deleted when the transaction exits (on both
         failure and success).
         """
         self._addbackupentry((location, b'', tmpfile, False))
 
     @active
     def addfilegenerator(
         self,
         genid,
         filenames,
         genfunc,
         order=0,
         location=b'',
         post_finalize=False,
     ):
         """add a function to generates some files at transaction commit
 
         The `genfunc` argument is a function capable of generating proper
         content of each entry in the `filename` tuple.
 
         At transaction close time, `genfunc` will be called with one file
         object argument per entries in `filenames`.
 
         The transaction itself is responsible for the backup, creation and
         final write of such file.
 
         The `genid` argument is used to ensure the same set of file is only
         generated once. Call to `addfilegenerator` for a `genid` already
         present will overwrite the old entry.
 
         The `order` argument may be used to control the order in which multiple
         generator will be executed.
 
         The `location` arguments may be used to indicate the files are located
         outside of the the standard directory for transaction. It should match
         one of the key of the `transaction.vfsmap` dictionary.
 
         The `post_finalize` argument can be set to `True` for file generation
         that must be run after the transaction has been finalized.
         """
         # For now, we are unable to do proper backup and restore of custom vfs
         # but for bookmarks that are handled outside this mechanism.
         entry = (order, filenames, genfunc, location, post_finalize)
         self._filegenerators[genid] = entry
 
     @active
     def removefilegenerator(self, genid):
         """reverse of addfilegenerator, remove a file generator function"""
         if genid in self._filegenerators:
             del self._filegenerators[genid]
 
     def _generatefiles(self, suffix=b'', group=GEN_GROUP_ALL):
         # write files registered for generation
         any = False
 
         if group == GEN_GROUP_ALL:
             skip_post = skip_pre = False
         else:
             skip_pre = group == GEN_GROUP_POST_FINALIZE
             skip_post = group == GEN_GROUP_PRE_FINALIZE
 
         for id, entry in sorted(self._filegenerators.items()):
             any = True
             order, filenames, genfunc, location, post_finalize = entry
 
             # for generation at closing, check if it's before or after finalize
             if skip_post and post_finalize:
                 continue
             elif skip_pre and not post_finalize:
                 continue
 
             vfs = self._vfsmap[location]
             files = []
             try:
                 for name in filenames:
                     name += suffix
                     if suffix:
                         self.registertmp(name, location=location)
                         checkambig = False
                     else:
                         self.addbackup(name, location=location)
                         checkambig = (name, location) in self._checkambigfiles
                     files.append(
                         vfs(name, b'w', atomictemp=True, checkambig=checkambig)
                     )
                 genfunc(*files)
                 for f in files:
                     f.close()
                 # skip discard() loop since we're sure no open file remains
                 del files[:]
             finally:
                 for f in files:
                     f.discard()
         return any
 
     @active
     def findoffset(self, file):
         if file in self._newfiles:
             return 0
         return self._offsetmap.get(file)
 
     @active
     def readjournal(self):
         self._file.seek(0)
         entries = []
         for l in self._file.readlines():
             file, troffset = l.split(b'\0')
             entries.append((file, int(troffset)))
         return entries
 
     @active
     def replace(self, file, offset):
         """
         replace can only replace already committed entries
         that are not pending in the queue
         """
         if file in self._newfiles:
             if not offset:
                 return
             self._newfiles.remove(file)
             self._offsetmap[file] = offset
         elif file in self._offsetmap:
             if not offset:
                 del self._offsetmap[file]
                 self._newfiles.add(file)
             else:
                 self._offsetmap[file] = offset
         else:
             raise KeyError(file)
         self._file.write(b"%s\0%d\n" % (file, offset))
         self._file.flush()
 
     @active
     def nest(self, name='<unnamed>'):
         self._count += 1
         self._usages += 1
         self._names.append(name)
         return self
 
     def release(self):
         if self._count > 0:
             self._usages -= 1
         if self._names:
             self._names.pop()
         # if the transaction scopes are left without being closed, fail
         if self._count > 0 and self._usages == 0:
             self._abort()
 
     def running(self):
         return self._count > 0
 
     def addpending(self, category, callback):
         """add a callback to be called when the transaction is pending
 
         The transaction will be given as callback's first argument.
 
         Category is a unique identifier to allow overwriting an old callback
         with a newer callback.
         """
         self._pendingcallback[category] = callback
 
     @active
     def writepending(self):
         """write pending file to temporary version
 
         This is used to allow hooks to view a transaction before commit"""
         categories = sorted(self._pendingcallback)
         for cat in categories:
             # remove callback since the data will have been flushed
             any = self._pendingcallback.pop(cat)(self)
             self._anypending = self._anypending or any
         self._anypending |= self._generatefiles(suffix=b'.pending')
         return self._anypending
 
     @active
     def hasfinalize(self, category):
         """check is a callback already exist for a category"""
         return category in self._finalizecallback
 
     @active
     def addfinalize(self, category, callback):
         """add a callback to be called when the transaction is closed
 
         The transaction will be given as callback's first argument.
 
         Category is a unique identifier to allow overwriting old callbacks with
         newer callbacks.
         """
         self._finalizecallback[category] = callback
 
     @active
     def addpostclose(self, category, callback):
         """add or replace a callback to be called after the transaction closed
 
         The transaction will be given as callback's first argument.
 
         Category is a unique identifier to allow overwriting an old callback
         with a newer callback.
         """
         self._postclosecallback[category] = callback
 
     @active
     def getpostclose(self, category):
         """return a postclose callback added before, or None"""
         return self._postclosecallback.get(category, None)
 
     @active
     def addabort(self, category, callback):
         """add a callback to be called when the transaction is aborted.
 
         The transaction will be given as the first argument to the callback.
 
         Category is a unique identifier to allow overwriting an old callback
         with a newer callback.
         """
         self._abortcallback[category] = callback
 
     @active
     def addvalidator(self, category, callback):
         """adds a callback to be called when validating the transaction.
 
         The transaction will be given as the first argument to the callback.
 
         callback should raise exception if to abort transaction"""
         self._validatecallback[category] = callback
 
     @active
     def close(self):
         '''commit the transaction'''
         if self._count == 1:
             for category in sorted(self._validatecallback):
                 self._validatecallback[category](self)
             self._validatecallback = None  # Help prevent cycles.
             self._generatefiles(group=GEN_GROUP_PRE_FINALIZE)
             while self._finalizecallback:
                 callbacks = self._finalizecallback
                 self._finalizecallback = {}
                 categories = sorted(callbacks)
                 for cat in categories:
                     callbacks[cat](self)
             # Prevent double usage and help clear cycles.
             self._finalizecallback = None
             self._generatefiles(group=GEN_GROUP_POST_FINALIZE)
 
         self._count -= 1
         if self._count != 0:
             return
         self._file.close()
         self._backupsfile.close()
         # cleanup temporary files
         for l, f, b, c in self._backupentries:
             if l not in self._vfsmap and c:
                 self._report(
                     b"couldn't remove %s: unknown cache location %s\n" % (b, l)
                 )
                 continue
             vfs = self._vfsmap[l]
             if not f and b and vfs.exists(b):
                 try:
                     vfs.unlink(b)
                 except (IOError, OSError, error.Abort) as inst:
                     if not c:
                         raise
                     # Abort may be raise by read only opener
                     self._report(
                         b"couldn't remove %s: %s\n" % (vfs.join(b), inst)
                     )
         self._offsetmap = {}
         self._newfiles = set()
         self._writeundo()
         if self._after:
             self._after()
             self._after = None  # Help prevent cycles.
         if self._opener.isfile(self._backupjournal):
             self._opener.unlink(self._backupjournal)
         if self._opener.isfile(self._journal):
             self._opener.unlink(self._journal)
         for l, _f, b, c in self._backupentries:
             if l not in self._vfsmap and c:
                 self._report(
                     b"couldn't remove %s: unknown cache location"
                     b"%s\n" % (b, l)
                 )
                 continue
             vfs = self._vfsmap[l]
             if b and vfs.exists(b):
                 try:
                     vfs.unlink(b)
                 except (IOError, OSError, error.Abort) as inst:
                     if not c:
                         raise
                     # Abort may be raise by read only opener
                     self._report(
                         b"couldn't remove %s: %s\n" % (vfs.join(b), inst)
                     )
         self._backupentries = []
         self._journal = None
 
         self._releasefn(self, True)  # notify success of closing transaction
         self._releasefn = None  # Help prevent cycles.
 
         # run post close action
         categories = sorted(self._postclosecallback)
         for cat in categories:
             self._postclosecallback[cat](self)
         # Prevent double usage and help clear cycles.
         self._postclosecallback = None
 
     @active
     def abort(self):
         """abort the transaction (generally called on error, or when the
         transaction is not explicitly committed before going out of
         scope)"""
         self._abort()
 
     def _writeundo(self):
         """write transaction data for possible future undo call"""
         if self._undoname is None:
             return
 
         undo_backup_path = b"%s.backupfiles" % self._undoname
         undobackupfile = self._opener.open(undo_backup_path, b'w')
         undobackupfile.write(b'%d\n' % version)
         for l, f, b, c in self._backupentries:
             if not f:  # temporary file
                 continue
             if not b:
                 u = b''
             else:
                 if l not in self._vfsmap and c:
                     self._report(
                         b"couldn't remove %s: unknown cache location"
                         b"%s\n" % (b, l)
                     )
                     continue
                 vfs = self._vfsmap[l]
                 base, name = vfs.split(b)
                 assert name.startswith(self._journal), name
                 uname = name.replace(self._journal, self._undoname, 1)
                 u = vfs.reljoin(base, uname)
                 util.copyfile(vfs.join(b), vfs.join(u), hardlink=True)
             undobackupfile.write(b"%s\0%s\0%s\0%d\n" % (l, f, u, c))
         undobackupfile.close()
 
     def _abort(self):
         entries = self.readjournal()
         self._count = 0
         self._usages = 0
         self._file.close()
         self._backupsfile.close()
 
         quick = self._can_quick_abort(entries)
         try:
             if not quick:
                 self._report(_(b"transaction abort!\n"))
             for cat in sorted(self._abortcallback):
                 self._abortcallback[cat](self)
             # Prevent double usage and help clear cycles.
             self._abortcallback = None
             if quick:
                 self._do_quick_abort(entries)
             else:
                 self._do_full_abort(entries)
         finally:
             self._journal = None
             self._releasefn(self, False)  # notify failure of transaction
             self._releasefn = None  # Help prevent cycles.
 
     def _can_quick_abort(self, entries):
         """False if any semantic content have been written on disk
 
         True if nothing, except temporary files has been writen on disk."""
         if entries:
             return False
-        if self._backupentries:
-            return False
+        for e in self._backupentries:
+            if e[1]:
+                return False
         return True
 
     def _do_quick_abort(self, entries):
         """(Silently) do a quick cleanup (see _can_quick_abort)"""
         assert self._can_quick_abort(entries)
+        tmp_files = [e for e in self._backupentries if not e[1]]
+        for vfs_id, old_path, tmp_path, xxx in tmp_files:
+            assert not old_path
+            vfs = self._vfsmap[vfs_id]
+            try:
+                vfs.unlink(tmp_path)
+            except FileNotFoundError:
+                pass
         if self._backupjournal:
             self._opener.unlink(self._backupjournal)
         if self._journal:
             self._opener.unlink(self._journal)
 
     def _do_full_abort(self, entries):
         """(Noisily) rollback all the change introduced by the transaction"""
         try:
             _playback(
                 self._journal,
                 self._report,
                 self._opener,
                 self._vfsmap,
                 entries,
                 self._backupentries,
                 False,
                 checkambigfiles=self._checkambigfiles,
             )
             self._report(_(b"rollback completed\n"))
         except BaseException as exc:
             self._report(_(b"rollback failed - please run hg recover\n"))
             self._report(
                 _(b"(failure reason: %s)\n") % stringutil.forcebytestr(exc)
             )
 
 
 BAD_VERSION_MSG = _(
     b"journal was created by a different version of Mercurial\n"
 )
 
 
 def rollback(opener, vfsmap, file, report, checkambigfiles=None):
     """Rolls back the transaction contained in the given file
 
     Reads the entries in the specified file, and the corresponding
     '*.backupfiles' file, to recover from an incomplete transaction.
 
     * `file`: a file containing a list of entries, specifying where
     to truncate each file.  The file should contain a list of
     file\0offset pairs, delimited by newlines. The corresponding
     '*.backupfiles' file should contain a list of file\0backupfile
     pairs, delimited by \0.
 
     `checkambigfiles` is a set of (path, vfs-location) tuples,
     which determine whether file stat ambiguity should be avoided at
     restoring corresponded files.
     """
     entries = []
     backupentries = []
 
     with opener.open(file) as fp:
         lines = fp.readlines()
     for l in lines:
         try:
             f, o = l.split(b'\0')
             entries.append((f, int(o)))
         except ValueError:
             report(
                 _(b"couldn't read journal entry %r!\n") % pycompat.bytestr(l)
             )
 
     backupjournal = b"%s.backupfiles" % file
     if opener.exists(backupjournal):
         fp = opener.open(backupjournal)
         lines = fp.readlines()
         if lines:
             ver = lines[0][:-1]
             if ver != (b'%d' % version):
                 report(BAD_VERSION_MSG)
             else:
                 for line in lines[1:]:
                     if line:
                         # Shave off the trailing newline
                         line = line[:-1]
                         l, f, b, c = line.split(b'\0')
                         backupentries.append((l, f, b, bool(c)))
 
     _playback(
         file,
         report,
         opener,
         vfsmap,
         entries,
         backupentries,
         checkambigfiles=checkambigfiles,
     )

tests/test-bookmarks.t

@@ -1,1261 +1,1253 b''
 
   $ hg init repo
   $ cd repo
 
   $ cat > $TESTTMP/hook.sh <<'EOF'
   > echo "test-hook-bookmark: $HG_BOOKMARK:  $HG_OLDNODE -> $HG_NODE"
   > EOF
   $ TESTHOOK="hooks.txnclose-bookmark.test=sh $TESTTMP/hook.sh"
 
 no bookmarks
 
   $ hg bookmarks
   no bookmarks set
 
   $ hg bookmarks -Tjson
   [
   ]
 
 bookmark rev -1
 
   $ hg bookmark X --config "$TESTHOOK"
   test-hook-bookmark: X:   -> 0000000000000000000000000000000000000000
 
 list bookmarks
 
   $ hg bookmarks
    * X                         -1:000000000000
 
 list bookmarks with color
 
   $ hg --config extensions.color= --config color.mode=ansi \
   >    bookmarks --color=always
   \x1b[0;32m * \x1b[0m\x1b[0;32mX\x1b[0m\x1b[0;32m                         -1:000000000000\x1b[0m (esc)
 
   $ echo a > a
   $ hg add a
   $ hg commit -m 0 --config "$TESTHOOK"
   test-hook-bookmark: X:  0000000000000000000000000000000000000000 -> f7b1eb17ad24730a1651fccd46c43826d1bbc2ac
 
 bookmark X moved to rev 0
 
   $ hg bookmarks
    * X                         0:f7b1eb17ad24
 
 look up bookmark
 
   $ hg log -r X
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
 
 second bookmark for rev 0, command should work even with ui.strict on
 
   $ hg --config ui.strict=1 bookmark X2 --config "$TESTHOOK"
   test-hook-bookmark: X2:   -> f7b1eb17ad24730a1651fccd46c43826d1bbc2ac
 
 bookmark rev -1 again
 
   $ hg bookmark -r null Y
 
 list bookmarks
 
   $ hg bookmarks
      X                         0:f7b1eb17ad24
    * X2                        0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l
      X                         0:f7b1eb17ad24
    * X2                        0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l X Y
      X                         0:f7b1eb17ad24
      Y                         -1:000000000000
   $ hg bookmarks -l .
    * X2                        0:f7b1eb17ad24
   $ hg bookmarks -l X A Y
   abort: bookmark 'A' does not exist
   [10]
   $ hg bookmarks -l -r0
   abort: cannot specify both --list and --rev
   [10]
   $ hg bookmarks -l --inactive
   abort: cannot specify both --inactive and --list
   [10]
 
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   0 X
   0 X2
 
   $ echo b > b
   $ hg add b
   $ hg commit -m 1 --config "$TESTHOOK"
   test-hook-bookmark: X2:  f7b1eb17ad24730a1651fccd46c43826d1bbc2ac -> 925d80f479bb026b0fb3deb27503780b13f74123
 
   $ hg bookmarks -T '{rev}:{node|shortest} {bookmark} {desc|firstline}\n'
   0:f7b1 X 0
   1:925d X2 1
   -1:0000 Y 
 
   $ hg bookmarks -Tjson
   [
    {
     "active": false,
     "bookmark": "X",
     "node": "f7b1eb17ad24730a1651fccd46c43826d1bbc2ac",
     "rev": 0
    },
    {
     "active": true,
     "bookmark": "X2",
     "node": "925d80f479bb026b0fb3deb27503780b13f74123",
     "rev": 1
    },
    {
     "active": false,
     "bookmark": "Y",
     "node": "0000000000000000000000000000000000000000",
     "rev": -1
    }
   ]
 
 bookmarks revset
 
   $ hg log -r 'bookmark()'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark(Y)'
   $ hg log -r 'bookmark(X2)'
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark("re:X")'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
   $ hg log -r 'bookmark("literal:X")'
   changeset:   0:f7b1eb17ad24
   bookmark:    X
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     0
   
 
 "." is expanded to the active bookmark:
 
   $ hg log -r 'bookmark(.)'
   changeset:   1:925d80f479bb
   bookmark:    X2
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1
   
 
 but "literal:." is not since "." seems not a literal bookmark:
 
   $ hg log -r 'bookmark("literal:.")'
   abort: bookmark '.' does not exist
   [10]
 
 "." should fail if there's no active bookmark:
 
   $ hg bookmark --inactive
   $ hg log -r 'bookmark(.)'
   abort: no active bookmark
   [10]
   $ hg log -r 'present(bookmark(.))'
 
   $ hg log -r 'bookmark(unknown)'
   abort: bookmark 'unknown' does not exist
   [10]
   $ hg log -r 'bookmark("literal:unknown")'
   abort: bookmark 'unknown' does not exist
   [10]
   $ hg log -r 'bookmark("re:unknown")'
   $ hg log -r 'present(bookmark("literal:unknown"))'
   $ hg log -r 'present(bookmark("re:unknown"))'
 
   $ hg help revsets | grep 'bookmark('
       "bookmark([name])"
 
 reactivate "X2"
 
   $ hg update X2
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark X2)
 
 bookmarks X and X2 moved to rev 1, Y at rev -1
 
   $ hg bookmarks
      X                         0:f7b1eb17ad24
    * X2                        1:925d80f479bb
      Y                         -1:000000000000
 
 bookmark rev 0 again
 
   $ hg bookmark -r 0 Z
 
   $ hg update X
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (activating bookmark X)
   $ echo c > c
   $ hg add c
   $ hg commit -m 2
   created new head
 
 bookmarks X moved to rev 2, Y at rev -1, Z at rev 0
 
   $ hg bookmarks
    * X                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         -1:000000000000
      Z                         0:f7b1eb17ad24
 
 rename nonexistent bookmark
 
   $ hg bookmark -m A B
   abort: bookmark 'A' does not exist
   [10]
 
 rename to existent bookmark
 
   $ hg bookmark -m X Y
   abort: bookmark 'Y' already exists (use -f to force)
   [255]
 
 force rename to existent bookmark
 
   $ hg bookmark -f -m X Y
 
 rename bookmark using .
 
   $ hg book rename-me
   $ hg book -m . renamed --config "$TESTHOOK"
   test-hook-bookmark: rename-me:  db815d6d32e69058eadefc8cffbad37675707975 -> 
   test-hook-bookmark: renamed:   -> db815d6d32e69058eadefc8cffbad37675707975
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
    * renamed                   2:db815d6d32e6
   $ hg up -q Y
   $ hg book -d renamed --config "$TESTHOOK"
   test-hook-bookmark: renamed:  db815d6d32e69058eadefc8cffbad37675707975 -> 
 
 rename bookmark using . with no active bookmark
 
   $ hg book rename-me
   $ hg book -i rename-me
   $ hg book -m . renamed
   abort: no active bookmark
   [10]
   $ hg up -q Y
   $ hg book -d rename-me
 
 delete bookmark using .
 
   $ hg book delete-me
   $ hg book -d .
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
   $ hg up -q Y
 
 delete bookmark using . with no active bookmark
 
   $ hg book delete-me
   $ hg book -i delete-me
   $ hg book -d .
   abort: no active bookmark
   [10]
   $ hg up -q Y
   $ hg book -d delete-me
 
 list bookmarks
 
   $ hg bookmark
      X2                        1:925d80f479bb
    * Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
 
 bookmarks from a revset
   $ hg bookmark -r '.^1' REVSET
   $ hg bookmark -r ':tip' TIP
   $ hg up -q TIP
   $ hg bookmarks
      REVSET                    0:f7b1eb17ad24
    * TIP                       2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
 
   $ hg bookmark -d REVSET
   $ hg bookmark -d TIP
 
 rename without new name or multiple names
 
   $ hg bookmark -m Y
   abort: new bookmark name required
   [10]
   $ hg bookmark -m Y Y2 Y3
   abort: only one new bookmark name allowed
   [10]
 
 delete without name
 
   $ hg bookmark -d
   abort: bookmark name required
   [10]
 
 delete nonexistent bookmark
 
   $ hg bookmark -d A
   abort: bookmark 'A' does not exist
   [10]
 
 delete with --inactive
 
   $ hg bookmark -d --inactive Y
   abort: cannot specify both --inactive and --delete
   [10]
 
 bookmark name with spaces should be stripped
 
   $ hg bookmark ' x  y '
 
 list bookmarks
 
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
    * x  y                      2:db815d6d32e6
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   2 Y
   2 x  y
   1 X2
   0 Z
 
 look up stripped bookmark name
 
   $ hg log -r '"x  y"'
   changeset:   2:db815d6d32e6
   bookmark:    Y
   bookmark:    x  y
   tag:         tip
   parent:      0:f7b1eb17ad24
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     2
   
 
 reject bookmark name with newline
 
   $ hg bookmark '
   > '
   abort: bookmark names cannot consist entirely of whitespace
   [10]
 
   $ hg bookmark -m Z '
   > '
   abort: bookmark names cannot consist entirely of whitespace
   [10]
 
 bookmark with reserved name
 
   $ hg bookmark tip
   abort: the name 'tip' is reserved
   [10]
 
   $ hg bookmark .
   abort: the name '.' is reserved
   [10]
 
   $ hg bookmark null
   abort: the name 'null' is reserved
   [10]
 
 
 bookmark with existing name
 
   $ hg bookmark X2
   abort: bookmark 'X2' already exists (use -f to force)
   [255]
 
   $ hg bookmark -m Y Z
   abort: bookmark 'Z' already exists (use -f to force)
   [255]
 
 bookmark with name of branch
 
   $ hg bookmark default
   abort: a bookmark cannot have the name of an existing branch
   [255]
 
   $ hg bookmark -m Y default
   abort: a bookmark cannot have the name of an existing branch
   [255]
 
 bookmark with integer name
 
   $ hg bookmark 10
   abort: cannot use an integer as a name
   [10]
 
 bookmark with a name that matches a node id
   $ hg bookmark 925d80f479bb db815d6d32e6 --config "$TESTHOOK"
   bookmark 925d80f479bb matches a changeset hash
   (did you leave a -r out of an 'hg bookmark' command?)
   bookmark db815d6d32e6 matches a changeset hash
   (did you leave a -r out of an 'hg bookmark' command?)
   test-hook-bookmark: 925d80f479bb:   -> db815d6d32e69058eadefc8cffbad37675707975
   test-hook-bookmark: db815d6d32e6:   -> db815d6d32e69058eadefc8cffbad37675707975
   $ hg bookmark -d 925d80f479bb
   $ hg bookmark -d db815d6d32e6
 
   $ cd ..
 
 bookmark with a name that matches an ambiguous node id
 
   $ hg init ambiguous
   $ cd ambiguous
   $ echo 0 > a
   $ hg ci -qAm 0
   $ for i in 1057 2857 4025; do
   >   hg up -q 0
   >   echo $i > a
   >   hg ci -qm $i
   > done
   $ hg up -q null
   $ hg log -r0: -T '{rev}:{node}\n'
   0:b4e73ffab476aa0ee32ed81ca51e07169844bc6a
   1:c56256a09cd28e5764f32e8e2810d0f01e2e357a
   2:c5623987d205cd6d9d8389bfc40fff9dbb670b48
   3:c562ddd9c94164376c20b86b0b4991636a3bf84f
 
   $ hg bookmark -r0 c562
   $ hg bookmarks
      c562                      0:b4e73ffab476
 
   $ cd ..
 
 incompatible options
 
   $ cd repo
 
   $ hg bookmark -m Y -d Z
   abort: cannot specify both --delete and --rename
   [10]
 
   $ hg bookmark -r 1 -d Z
   abort: cannot specify both --delete and --rev
   [10]
 
   $ hg bookmark -r 1 -m Z Y
   abort: cannot specify both --rename and --rev
   [10]
 
 force bookmark with existing name
 
   $ hg bookmark -f X2 --config "$TESTHOOK"
   test-hook-bookmark: X2:  925d80f479bb026b0fb3deb27503780b13f74123 -> db815d6d32e69058eadefc8cffbad37675707975
 
 force bookmark back to where it was, should deactivate it
 
   $ hg bookmark -fr1 X2
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         0:f7b1eb17ad24
      x  y                      2:db815d6d32e6
 
 forward bookmark to descendant without --force
 
   $ hg bookmark Z
   moving bookmark 'Z' forward from f7b1eb17ad24
 
 list bookmarks
 
   $ hg bookmark
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg log -T '{bookmarks % "{rev} {bookmark}\n"}'
   2 Y
   2 Z
   2 x  y
   1 X2
 
 revision but no bookmark name
 
   $ hg bookmark -r .
   abort: bookmark name required
   [10]
 
 bookmark name with whitespace only
 
   $ hg bookmark ' '
   abort: bookmark names cannot consist entirely of whitespace
   [10]
 
   $ hg bookmark -m Y ' '
   abort: bookmark names cannot consist entirely of whitespace
   [10]
 
 invalid bookmark
 
   $ hg bookmark 'foo:bar'
   abort: ':' cannot be used in a name
   [10]
 
   $ hg bookmark 'foo
   > bar'
   abort: '\n' cannot be used in a name
   [10]
 
 the bookmark extension should be ignored now that it is part of core
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "bookmarks=" >> $HGRCPATH
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 test summary
 
   $ hg summary
   parent: 2:db815d6d32e6 tip
    2
   branch: default
   bookmarks: *Z Y x  y
   commit: (clean)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft
 
 test id
 
   $ hg id
   db815d6d32e6 tip Y/Z/x  y
 
 test rollback
 
   $ echo foo > f1
   $ hg bookmark tmp-rollback
   $ hg add .
   adding f1
   $ hg ci -mr
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              3:2bf5cfec5864
      x  y                      2:db815d6d32e6
   $ hg rollback
   repository tip rolled back to revision 2 (undo commit)
   working directory now based on revision 2
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg bookmark -f Z -r 1
   $ hg rollback
   repository tip rolled back to revision 2 (undo bookmark)
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
    * tmp-rollback              2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg bookmark -d tmp-rollback
 
 activate bookmark on working dir parent without --force
 
   $ hg bookmark --inactive Z
   $ hg bookmark Z
 
 deactivate current 'Z', but also add 'Y'
 
   $ hg bookmark -d Y
   $ hg bookmark --inactive Z Y
   $ hg bookmark -l
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg bookmark Z
 
 bookmark wdir to activate it (issue6218)
 
   $ hg bookmark -d Z
   $ hg bookmark -r 'wdir()' Z
   $ hg bookmark -l
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 test clone
 
   $ hg bookmark -r 2 -i @
   $ hg bookmark -r 2 -i a@
   $ hg bookmarks
      @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg clone . cloned-bookmarks
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks bookmarks
    * @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 test clone with pull protocol
 
   $ hg clone --pull . cloned-bookmarks-pull
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 3 files (+1 heads)
   new changesets f7b1eb17ad24:db815d6d32e6
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks-pull bookmarks
    * @                         2:db815d6d32e6
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      a@                        2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 delete multiple bookmarks at once
 
   $ hg bookmark -d @ a@
 
 test clone with a bookmark named "default" (issue3677)
 
   $ hg bookmark -r 1 -f -i default
   $ hg clone . cloned-bookmark-default
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmark-default bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
      Z                         2:db815d6d32e6
      default                   1:925d80f479bb
      x  y                      2:db815d6d32e6
   $ hg -R cloned-bookmark-default parents -q
   2:db815d6d32e6
   $ hg bookmark -d default
 
 test clone with a specific revision
 
   $ hg clone -r 925d80 . cloned-bookmarks-rev
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   new changesets f7b1eb17ad24:925d80f479bb
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R cloned-bookmarks-rev bookmarks
      X2                        1:925d80f479bb
 
 test clone with update to a bookmark
 
   $ hg clone -u Z . ../cloned-bookmarks-update
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R ../cloned-bookmarks-update bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
 
 create bundle with two heads
 
   $ hg clone . tobundle
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo x > tobundle/x
   $ hg -R tobundle add tobundle/x
   $ hg -R tobundle commit -m'x'
   $ hg -R tobundle update -r -2
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo y > tobundle/y
   $ hg -R tobundle branch test
   marked working directory as branch test
   (branches are permanent and global, did you want a bookmark?)
   $ hg -R tobundle add tobundle/y
   $ hg -R tobundle commit -m'y'
   $ hg -R tobundle bundle tobundle.hg
   searching for changes
   2 changesets found
   $ hg unbundle tobundle.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3 (2 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 update to active bookmark if it's not the parent
 
 (it is known issue that fsmonitor can't handle nested repositories. In
 this test scenario, cloned-bookmark-default and tobundle exist in the
 working directory of current repository)
 
   $ hg summary
   parent: 2:db815d6d32e6 
    2
   branch: default
   bookmarks: *Z Y x  y
   commit: 1 added, 1 unknown (new branch head) (no-fsmonitor !)
   commit: 1 added, * unknown (new branch head) (glob) (fsmonitor !)
   update: 2 new changesets (update)
   phases: 5 draft
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark Z
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         2:db815d6d32e6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
 
 pull --update works the same as pull && update
 
   $ hg bookmark -r3 Y
   moving bookmark 'Y' forward from db815d6d32e6
   $ cp -R ../cloned-bookmarks-update ../cloned-bookmarks-manual-update
   $ cp -R ../cloned-bookmarks-update ../cloned-bookmarks-manual-update-with-divergence
 
 (manual version)
 
   $ hg -R ../cloned-bookmarks-manual-update update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-manual-update pull .
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   updating bookmark Z
   added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 (# tests strange but with --date crashing when bookmark have to move)
 
   $ hg -R ../cloned-bookmarks-manual-update update -d 1986
   abort: revision matching date not found
   [10]
   $ hg -R ../cloned-bookmarks-manual-update update
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 (all in one version)
 
   $ hg -R ../cloned-bookmarks-update update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-update pull --update .
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   updating bookmark Z
   added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 We warn about divergent during bare update to the active bookmark
 
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence update Y
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark Y)
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence bookmarks -r X2 Y@1
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence bookmarks
      X2                        1:925d80f479bb
    * Y                         2:db815d6d32e6
      Y@1                       1:925d80f479bb
      Z                         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence pull
   pulling from $TESTTMP/repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   updating bookmark Y
   updating bookmark Z
   added 2 changesets with 2 changes to 2 files (+1 heads)
   new changesets 125c9a1d6df6:9ba5f110a0b3
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg -R ../cloned-bookmarks-manual-update-with-divergence update
   updating to active bookmark Y
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   1 other divergent bookmarks for "Y"
 
 test wrongly formated bookmark
 
   $ echo '' >> .hg/bookmarks
   $ hg bookmarks
      X2                        1:925d80f479bb
      Y                         3:125c9a1d6df6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
   $ echo "Ican'thasformatedlines" >> .hg/bookmarks
   $ hg bookmarks
   malformed line in .hg/bookmarks: "Ican'thasformatedlines"
      X2                        1:925d80f479bb
      Y                         3:125c9a1d6df6
    * Z                         3:125c9a1d6df6
      x  y                      2:db815d6d32e6
 
 test missing revisions
 
   $ echo "925d80f479b925d80f479bc925d80f479bccabab z" > .hg/bookmarks
   $ hg book
   no bookmarks set
 
 test stripping a non-checked-out but bookmarked revision
 
   $ hg log --graph
   o  changeset:   4:9ba5f110a0b3
   |  branch:      test
   |  tag:         tip
   |  parent:      2:db815d6d32e6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     y
   |
   | @  changeset:   3:125c9a1d6df6
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     x
   |
   o  changeset:   2:db815d6d32e6
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
   $ hg book should-end-on-two
   $ hg co --clean 4
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   (leaving bookmark should-end-on-two)
   $ hg book four
   $ hg --config extensions.mq= strip 3
   saved backup bundle to * (glob)
 should-end-on-two should end up pointing to revision 2, as that's the
 tipmost surviving ancestor of the stripped revision.
   $ hg log --graph
   @  changeset:   3:9ba5f110a0b3
   |  branch:      test
   |  bookmark:    four
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     y
   |
   o  changeset:   2:db815d6d32e6
   |  bookmark:    should-end-on-two
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
 no-op update doesn't deactivate bookmarks
 
 (it is known issue that fsmonitor can't handle nested repositories. In
 this test scenario, cloned-bookmark-default and tobundle exist in the
 working directory of current repository)
 
   $ hg bookmarks
    * four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
   $ hg up four
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg sum
   parent: 3:9ba5f110a0b3 tip
    y
   branch: test
   bookmarks: *four
   commit: 2 unknown (clean) (no-fsmonitor !)
   commit: * unknown (clean) (glob) (fsmonitor !)
   update: (current)
   phases: 4 draft
 
 test clearing divergent bookmarks of linear ancestors
 
   $ hg bookmark Z -r 0
   $ hg bookmark Z@1 -r 1
   $ hg bookmark Z@2 -r 2
   $ hg bookmark Z@3 -r 3
   $ hg book
      Z                         0:f7b1eb17ad24
      Z@1                       1:925d80f479bb
      Z@2                       2:db815d6d32e6
      Z@3                       3:9ba5f110a0b3
    * four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
   $ hg bookmark Z
   moving bookmark 'Z' forward from f7b1eb17ad24
   $ hg book
    * Z                         3:9ba5f110a0b3
      Z@1                       1:925d80f479bb
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
 
 test clearing only a single divergent bookmark across branches
 
   $ hg book foo -r 1
   $ hg book foo@1 -r 0
   $ hg book foo@2 -r 2
   $ hg book foo@3 -r 3
   $ hg book foo -r foo@3
   $ hg book
    * Z                         3:9ba5f110a0b3
      Z@1                       1:925d80f479bb
      foo                       3:9ba5f110a0b3
      foo@1                     0:f7b1eb17ad24
      foo@2                     2:db815d6d32e6
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
 
 pull --update works the same as pull && update (case #2)
 
 It is assumed that "hg pull" itself doesn't update current active
 bookmark ('Y' in tests below).
 
   $ hg pull -q ../cloned-bookmarks-update
   divergent bookmark Z stored as Z@2
 
 (pulling revision on another named branch with --update updates
 neither the working directory nor current active bookmark: "no-op"
 case)
 
   $ echo yy >> y
   $ hg commit -m yy
 
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update path
   default = $TESTTMP/repo
   $ pwd
   $TESTTMP/repo
   $ hg -R ../cloned-bookmarks-update pull . --update
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   divergent bookmark Z stored as Z@default
   adding remote bookmark foo
   adding remote bookmark four
   adding remote bookmark should-end-on-two
   added 1 changesets with 1 changes to 1 files
   new changesets 5fb12f0f2d51
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R ../cloned-bookmarks-update parents -T "{rev}:{node|short}\n"
   3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
 
 (pulling revision on current named/topological branch with --update
 updates the working directory and current active bookmark)
 
   $ hg update -C -q 125c9a1d6df6
   $ echo xx >> x
   $ hg commit -m xx
 
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         3:125c9a1d6df6
   $ hg -R ../cloned-bookmarks-update pull . --update
   pulling from .
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   divergent bookmark Z stored as Z@default
   added 1 changesets with 1 changes to 1 files
   new changesets 81dcce76aa0b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updating bookmark Y
   $ hg -R ../cloned-bookmarks-update parents -T "{rev}:{node|short}\n"
   6:81dcce76aa0b
   $ hg -R ../cloned-bookmarks-update bookmarks | grep ' Y '
    * Y                         6:81dcce76aa0b
 
   $ cd ..
 
 ensure changelog is written before bookmarks
   $ hg init orderrepo
   $ cd orderrepo
   $ touch a
   $ hg commit -Aqm one
   $ hg book mybook
   $ echo a > a
 
   $ cat > $TESTTMP/pausefinalize.py <<EOF
   > import os
   > import time
   > from mercurial import extensions, localrepo
   > def transaction(orig, self, desc, report=None):
   >    tr = orig(self, desc, report)
   >    def sleep(*args, **kwargs):
   >        retry = 20
   >        while retry > 0 and not os.path.exists(b"$TESTTMP/unpause"):
   >            retry -= 1
   >            time.sleep(0.5)
   >        if os.path.exists(b"$TESTTMP/unpause"):
   >            os.remove(b"$TESTTMP/unpause")
   >    # It is important that this finalizer start with 'a', so it runs before
   >    # the changelog finalizer appends to the changelog.
   >    tr.addfinalize(b'a-sleep', sleep)
   >    return tr
   > 
   > def extsetup(ui):
   >    # This extension inserts an artifical pause during the transaction
   >    # finalizer, so we can run commands mid-transaction-close.
   >    extensions.wrapfunction(localrepo.localrepository, 'transaction',
   >                            transaction)
   > EOF
   $ hg commit -qm two --config extensions.pausefinalize=$TESTTMP/pausefinalize.py &
   $ sleep 2
   $ hg log -r .
   changeset:   0:867bc5792c8c
   bookmark:    mybook
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     one
   
   $ hg bookmarks
    * mybook                    0:867bc5792c8c
   $ touch $TESTTMP/unpause
 
   $ cd ..
 
 check whether HG_PENDING makes pending changes only in related
 repositories visible to an external hook.
 
 (emulate a transaction running concurrently by copied
 .hg/bookmarks.pending in subsequent test)
 
   $ cat > $TESTTMP/savepending.sh <<EOF
   > cp .hg/bookmarks.pending .hg/bookmarks.pending.saved
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ hg init unrelated
   $ cd unrelated
   $ echo a > a
   $ hg add a
   $ hg commit -m '#0'
   $ hg --config hooks.pretxnclose="sh $TESTTMP/savepending.sh" bookmarks INVISIBLE
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
   $ cp .hg/bookmarks.pending.saved .hg/bookmarks.pending
 
 (check visible bookmarks while transaction running in repo)
 
   $ cat > $TESTTMP/checkpending.sh <<EOF
   > echo "@repo"
   > hg -R "$TESTTMP/repo" bookmarks
   > echo "@unrelated"
   > hg -R "$TESTTMP/unrelated" bookmarks
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ cd ../repo
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkpending.sh" bookmarks NEW
   @repo
    * NEW                       6:81dcce76aa0b
      X2                        1:925d80f479bb
      Y                         4:125c9a1d6df6
      Z                         5:5fb12f0f2d51
      Z@1                       1:925d80f479bb
      Z@2                       4:125c9a1d6df6
      foo                       3:9ba5f110a0b3
      foo@1                     0:f7b1eb17ad24
      foo@2                     2:db815d6d32e6
      four                      3:9ba5f110a0b3
      should-end-on-two         2:db815d6d32e6
      x  y                      2:db815d6d32e6
   @unrelated
   no bookmarks set
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
 
 Check pretxnclose-bookmark can abort a transaction
 --------------------------------------------------
 
 add hooks:
 
 * to prevent NEW bookmark on a non-public changeset
 * to prevent non-forward move of NEW bookmark
 
   $ cat << EOF >> .hg/hgrc
   > [hooks]
   > pretxnclose-bookmark.force-public  = sh -c "(echo \$HG_BOOKMARK| grep -v NEW > /dev/null) || [ -z \"\$HG_NODE\" ] || (hg log -r \"\$HG_NODE\" -T '{phase}' | grep public > /dev/null)"
   > pretxnclose-bookmark.force-forward = sh -c "(echo \$HG_BOOKMARK| grep -v NEW > /dev/null) || [ -z \"\$HG_NODE\" ] || (hg log -r \"max(\$HG_OLDNODE::\$HG_NODE)\" -T 'MATCH' | grep MATCH > /dev/null)"
   > EOF
 
   $ hg log -G -T phases
   @  changeset:   6:81dcce76aa0b
   |  tag:         tip
   |  phase:       draft
   |  parent:      4:125c9a1d6df6
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     xx
   |
   | o  changeset:   5:5fb12f0f2d51
   | |  branch:      test
   | |  bookmark:    Z
   | |  phase:       draft
   | |  parent:      3:9ba5f110a0b3
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     yy
   | |
   o |  changeset:   4:125c9a1d6df6
   | |  bookmark:    Y
   | |  bookmark:    Z@2
   | |  phase:       public
   | |  parent:      2:db815d6d32e6
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     x
   | |
   | o  changeset:   3:9ba5f110a0b3
   |/   branch:      test
   |    bookmark:    foo
   |    bookmark:    four
   |    phase:       public
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     y
   |
   o  changeset:   2:db815d6d32e6
   |  bookmark:    foo@2
   |  bookmark:    should-end-on-two
   |  bookmark:    x  y
   |  phase:       public
   |  parent:      0:f7b1eb17ad24
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     2
   |
   | o  changeset:   1:925d80f479bb
   |/   bookmark:    X2
   |    bookmark:    Z@1
   |    phase:       public
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     1
   |
   o  changeset:   0:f7b1eb17ad24
      bookmark:    foo@1
      phase:       public
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     0
   
 
 attempt to create on a default changeset
 
   $ hg bookmark -r 81dcce76aa0b NEW
-  transaction abort!
-  rollback completed
   abort: pretxnclose-bookmark.force-public hook exited with status 1
   [40]
 
 create on a public changeset
 
   $ hg bookmark -r 9ba5f110a0b3 NEW
 
 move to the other branch
 
   $ hg bookmark -f -r 125c9a1d6df6 NEW
-  transaction abort!
-  rollback completed
   abort: pretxnclose-bookmark.force-forward hook exited with status 1
   [40]

tests/test-phases.t

@@ -1,1141 +1,1131 b''
   $ cat > $TESTTMP/hook.sh << 'EOF'
   > echo "test-hook-close-phase: $HG_NODE:  $HG_OLDPHASE -> $HG_PHASE"
   > EOF
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > phasereport=$TESTDIR/testlib/ext-phase-report.py
   > [hooks]
   > txnclose-phase.test = sh $TESTTMP/hook.sh
   > EOF
 
   $ hglog() { hg log -G --template "{rev} {phaseidx} {desc}\n" $*; }
   $ mkcommit() {
   >    echo "$1" > "$1"
   >    hg add "$1"
   >    message="$1"
   >    shift
   >    hg ci -m "$message" $*
   > }
 
   $ hg init initialrepo
   $ cd initialrepo
 
 Cannot change null revision phase
 
   $ hg phase --force --secret null
   abort: cannot change null revision phase
   [255]
   $ hg phase null
   -1: public
 
   $ mkcommit A
   test-debug-phase: new rev 0:  x -> 1
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> draft
 
 New commit are draft by default
 
   $ hglog
   @  0 1 A
   
 
 Following commit are draft too
 
   $ mkcommit B
   test-debug-phase: new rev 1:  x -> 1
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> draft
 
   $ hglog
   @  1 1 B
   |
   o  0 1 A
   
 
 Working directory phase is secret when its parent is secret.
 
   $ hg phase --force --secret .
   test-debug-phase: move rev 0: 1 -> 2
   test-debug-phase: move rev 1: 1 -> 2
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:  draft -> secret
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:  draft -> secret
   $ hg log -r 'wdir()' -T '{phase}\n'
   secret
   $ hg log -r 'wdir() and public()' -T '{phase}\n'
   $ hg log -r 'wdir() and draft()' -T '{phase}\n'
   $ hg log -r 'wdir() and secret()' -T '{phase}\n'
   secret
 
 Working directory phase is draft when its parent is draft.
 
   $ hg phase --draft .
   test-debug-phase: move rev 1: 2 -> 1
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:  secret -> draft
   $ hg log -r 'wdir()' -T '{phase}\n'
   draft
   $ hg log -r 'wdir() and public()' -T '{phase}\n'
   $ hg log -r 'wdir() and draft()' -T '{phase}\n'
   draft
   $ hg log -r 'wdir() and secret()' -T '{phase}\n'
 
 Working directory phase is secret when a new commit will be created as secret,
 even if the parent is draft.
 
   $ hg log -r 'wdir() and secret()' -T '{phase}\n' \
   > --config phases.new-commit='secret'
   secret
 
 Working directory phase is draft when its parent is public.
 
   $ hg phase --public .
   test-debug-phase: move rev 0: 1 -> 0
   test-debug-phase: move rev 1: 1 -> 0
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:  draft -> public
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:  draft -> public
   $ hg log -r 'wdir()' -T '{phase}\n'
   draft
   $ hg log -r 'wdir() and public()' -T '{phase}\n'
   $ hg log -r 'wdir() and draft()' -T '{phase}\n'
   draft
   $ hg log -r 'wdir() and secret()' -T '{phase}\n'
   $ hg log -r 'wdir() and secret()' -T '{phase}\n' \
   > --config phases.new-commit='secret'
   secret
 
 Draft commit are properly created over public one:
 
   $ hg phase
   1: public
   $ hglog
   @  1 0 B
   |
   o  0 0 A
   
 
   $ mkcommit C
   test-debug-phase: new rev 2:  x -> 1
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:   -> draft
   $ mkcommit D
   test-debug-phase: new rev 3:  x -> 1
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:   -> draft
 
   $ hglog
   @  3 1 D
   |
   o  2 1 C
   |
   o  1 0 B
   |
   o  0 0 A
   
 
 Test creating changeset as secret
 
   $ mkcommit E --config phases.new-commit='secret'
   test-debug-phase: new rev 4:  x -> 2
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:   -> secret
   $ hglog
   @  4 2 E
   |
   o  3 1 D
   |
   o  2 1 C
   |
   o  1 0 B
   |
   o  0 0 A
   
 
 Test the secret property is inherited
 
   $ mkcommit H
   test-debug-phase: new rev 5:  x -> 2
   test-hook-close-phase: a030c6be5127abc010fcbff1851536552e6951a8:   -> secret
   $ hglog
   @  5 2 H
   |
   o  4 2 E
   |
   o  3 1 D
   |
   o  2 1 C
   |
   o  1 0 B
   |
   o  0 0 A
   
 
 Even on merge
 
   $ hg up -q 1
   $ mkcommit "B'"
   test-debug-phase: new rev 6:  x -> 1
   created new head
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:   -> draft
   $ hglog
   @  6 1 B'
   |
   | o  5 2 H
   | |
   | o  4 2 E
   | |
   | o  3 1 D
   | |
   | o  2 1 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
   $ hg merge 4 # E
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg phase
   6: draft
   4: secret
   $ hg ci -m "merge B' and E"
   test-debug-phase: new rev 7:  x -> 2
   test-hook-close-phase: 17a481b3bccb796c0521ae97903d81c52bfee4af:   -> secret
 
   $ hglog
   @    7 2 merge B' and E
   |\
   | o  6 1 B'
   | |
   +---o  5 2 H
   | |
   o |  4 2 E
   | |
   o |  3 1 D
   | |
   o |  2 1 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
 
 Test secret changeset are not pushed
 
   $ hg init ../push-dest
   $ cat > ../push-dest/.hg/hgrc << EOF
   > [phases]
   > publish=False
   > EOF
   $ hg outgoing ../push-dest --template='{rev} {phase} {desc|firstline}\n'
   comparing with ../push-dest
   searching for changes
   0 public A
   1 public B
   2 draft C
   3 draft D
   6 draft B'
   $ hg outgoing -r 'branch(default)' ../push-dest --template='{rev} {phase} {desc|firstline}\n'
   comparing with ../push-dest
   searching for changes
   0 public A
   1 public B
   2 draft C
   3 draft D
   6 draft B'
 
   $ hg push ../push-dest -f # force because we push multiple heads
   pushing to ../push-dest
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 5 files (+1 heads)
   test-debug-phase: new rev 0:  x -> 0
   test-debug-phase: new rev 1:  x -> 0
   test-debug-phase: new rev 2:  x -> 1
   test-debug-phase: new rev 3:  x -> 1
   test-debug-phase: new rev 4:  x -> 1
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> public
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> public
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:   -> draft
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:   -> draft
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:   -> draft
   $ hglog
   @    7 2 merge B' and E
   |\
   | o  6 1 B'
   | |
   +---o  5 2 H
   | |
   o |  4 2 E
   | |
   o |  3 1 D
   | |
   o |  2 1 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
   $ cd ../push-dest
   $ hglog
   o  4 1 B'
   |
   | o  3 1 D
   | |
   | o  2 1 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
 
 (Issue3303)
 Check that remote secret changeset are ignore when checking creation of remote heads
 
 We add a secret head into the push destination. This secret head shadows a
 visible shared between the initial repo and the push destination.
 
   $ hg up -q 4 # B'
   $ mkcommit Z --config phases.new-commit=secret
   test-debug-phase: new rev 5:  x -> 2
   test-hook-close-phase: 2713879da13d6eea1ff22b442a5a87cb31a7ce6a:   -> secret
   $ hg phase .
   5: secret
 
 We now try to push a new public changeset that descend from the common public
 head shadowed by the remote secret head.
 
   $ cd ../initialrepo
   $ hg up -q 6 #B'
   $ mkcommit I
   test-debug-phase: new rev 8:  x -> 1
   created new head
   test-hook-close-phase: 6d6770faffce199f1fddd1cf87f6f026138cf061:   -> draft
   $ hg push ../push-dest
   pushing to ../push-dest
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   test-debug-phase: new rev 6:  x -> 1
   test-hook-close-phase: 6d6770faffce199f1fddd1cf87f6f026138cf061:   -> draft
 
 :note: The "(+1 heads)" is wrong as we do not had any visible head
 
 check that branch cache with "served" filter are properly computed and stored
 
   $ ls ../push-dest/.hg/cache/branch2*
   ../push-dest/.hg/cache/branch2-base
   ../push-dest/.hg/cache/branch2-served
   $ cat ../push-dest/.hg/cache/branch2-served
   6d6770faffce199f1fddd1cf87f6f026138cf061 6 465891ffab3c47a3c23792f7dc84156e19a90722
   b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e o default
   6d6770faffce199f1fddd1cf87f6f026138cf061 o default
   $ hg heads -R ../push-dest --template '{rev}:{node} {phase}\n'  #update visible cache too
   6:6d6770faffce199f1fddd1cf87f6f026138cf061 draft
   5:2713879da13d6eea1ff22b442a5a87cb31a7ce6a secret
   3:b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e draft
   $ ls ../push-dest/.hg/cache/branch2*
   ../push-dest/.hg/cache/branch2-base
   ../push-dest/.hg/cache/branch2-served
   ../push-dest/.hg/cache/branch2-visible
   $ cat ../push-dest/.hg/cache/branch2-served
   6d6770faffce199f1fddd1cf87f6f026138cf061 6 465891ffab3c47a3c23792f7dc84156e19a90722
   b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e o default
   6d6770faffce199f1fddd1cf87f6f026138cf061 o default
   $ cat ../push-dest/.hg/cache/branch2-visible
   6d6770faffce199f1fddd1cf87f6f026138cf061 6
   b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e o default
   2713879da13d6eea1ff22b442a5a87cb31a7ce6a o default
   6d6770faffce199f1fddd1cf87f6f026138cf061 o default
 
 
 Restore condition prior extra insertion.
   $ hg -q --config extensions.mq= strip .
   $ hg up -q 7
   $ cd ..
 
 Test secret changeset are not pull
 
   $ hg init pull-dest
   $ cd pull-dest
   $ hg pull ../initialrepo
   pulling from ../initialrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 5 changesets with 5 changes to 5 files (+1 heads)
   new changesets 4a2df7238c3b:cf9fe039dfd6
   test-debug-phase: new rev 0:  x -> 0
   test-debug-phase: new rev 1:  x -> 0
   test-debug-phase: new rev 2:  x -> 0
   test-debug-phase: new rev 3:  x -> 0
   test-debug-phase: new rev 4:  x -> 0
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> public
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> public
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:   -> public
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:   -> public
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:   -> public
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hglog
   o  4 0 B'
   |
   | o  3 0 D
   | |
   | o  2 0 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
   $ cd ..
 
 But secret can still be bundled explicitly
 
   $ cd initialrepo
   $ hg bundle --base '4^' -r 'children(4)' ../secret-bundle.hg
   4 changesets found
   $ cd ..
 
 Test secret changeset are not cloned
 (during local clone)
 
   $ hg clone -qU initialrepo clone-dest
   test-debug-phase: new rev 0:  x -> 0
   test-debug-phase: new rev 1:  x -> 0
   test-debug-phase: new rev 2:  x -> 0
   test-debug-phase: new rev 3:  x -> 0
   test-debug-phase: new rev 4:  x -> 0
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> public
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> public
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:   -> public
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:   -> public
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:   -> public
   $ hglog -R clone-dest
   o  4 0 B'
   |
   | o  3 0 D
   | |
   | o  2 0 C
   |/
   o  1 0 B
   |
   o  0 0 A
   
 
 Test summary
 
   $ hg summary -R clone-dest --verbose
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 5 new changesets (update)
   $ hg summary -R initialrepo
   parent: 7:17a481b3bccb tip
    merge B' and E
   branch: default
   commit: (clean) (secret)
   update: 1 new changesets, 2 branch heads (merge)
   phases: 3 draft, 3 secret
   $ hg summary -R initialrepo --quiet
   parent: 7:17a481b3bccb tip
   update: 1 new changesets, 2 branch heads (merge)
 
 Test revset
 
   $ cd initialrepo
   $ hglog -r 'public()'
   o  1 0 B
   |
   o  0 0 A
   
   $ hglog -r 'draft()'
   o  6 1 B'
   |
   ~
   o  3 1 D
   |
   o  2 1 C
   |
   ~
   $ hglog -r 'secret()'
   @    7 2 merge B' and E
   |\
   | ~
   | o  5 2 H
   |/
   o  4 2 E
   |
   ~
 
 test that phase are displayed in log at debug level
 
   $ hg log --debug
   changeset:   7:17a481b3bccb796c0521ae97903d81c52bfee4af
   tag:         tip
   phase:       secret
   parent:      6:cf9fe039dfd67e829edf6522a45de057b5c86519
   parent:      4:a603bfb5a83e312131cebcd05353c217d4d21dde
   manifest:    7:5e724ffacba267b2ab726c91fc8b650710deaaa8
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   extra:       branch=default
   description:
   merge B' and E
   
   
   changeset:   6:cf9fe039dfd67e829edf6522a45de057b5c86519
   phase:       draft
   parent:      1:27547f69f25460a52fff66ad004e58da7ad3fb56
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    6:ab8bfef2392903058bf4ebb9e7746e8d7026b27a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      B'
   extra:       branch=default
   description:
   B'
   
   
   changeset:   5:a030c6be5127abc010fcbff1851536552e6951a8
   phase:       secret
   parent:      4:a603bfb5a83e312131cebcd05353c217d4d21dde
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    5:5c710aa854874fe3d5fa7192e77bdb314cc08b5a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      H
   extra:       branch=default
   description:
   H
   
   
   changeset:   4:a603bfb5a83e312131cebcd05353c217d4d21dde
   phase:       secret
   parent:      3:b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    4:7173fd1c27119750b959e3a0f47ed78abe75d6dc
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      E
   extra:       branch=default
   description:
   E
   
   
   changeset:   3:b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e
   phase:       draft
   parent:      2:f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:6e1f4c47ecb533ffd0c8e52cdc88afb6cd39e20c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      D
   extra:       branch=default
   description:
   D
   
   
   changeset:   2:f838bfaca5c7226600ebcfd84f3c3c13a28d3757
   phase:       draft
   parent:      1:27547f69f25460a52fff66ad004e58da7ad3fb56
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    2:66a5a01817fdf5239c273802b5b7618d051c89e4
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      C
   extra:       branch=default
   description:
   C
   
   
   changeset:   1:27547f69f25460a52fff66ad004e58da7ad3fb56
   phase:       public
   parent:      0:4a2df7238c3b48766b5e22fafbb8a2f506ec8256
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    1:cb5cbbc1bfbf24cc34b9e8c16914e9caa2d2a7fd
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      B
   extra:       branch=default
   description:
   B
   
   
   changeset:   0:4a2df7238c3b48766b5e22fafbb8a2f506ec8256
   phase:       public
   parent:      -1:0000000000000000000000000000000000000000
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    0:007d8c9d88841325f5c6b06371b35b4e8a2b1a83
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      A
   extra:       branch=default
   description:
   A
   
   
 
 
 (Issue3707)
 test invalid phase name
 
   $ mkcommit I --config phases.new-commit='babar'
   transaction abort!
   rollback completed
   config error: phases.new-commit: not a valid phase name ('babar')
   [30]
 Test phase command
 ===================
 
 initial picture
 
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    7 secret merge B' and E
   |\
   | o  6 draft B'
   | |
   +---o  5 secret H
   | |
   o |  4 secret E
   | |
   o |  3 draft D
   | |
   o |  2 draft C
   |/
   o  1 public B
   |
   o  0 public A
   
 
 display changesets phase
 
 (mixing -r and plain rev specification)
 
   $ hg phase 1::4 -r 7
   1: public
   2: draft
   3: draft
   4: secret
   7: secret
 
 
 move changeset forward
 
 (with -r option)
 
   $ hg phase --public -r 2
   test-debug-phase: move rev 2: 1 -> 0
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:  draft -> public
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    7 secret merge B' and E
   |\
   | o  6 draft B'
   | |
   +---o  5 secret H
   | |
   o |  4 secret E
   | |
   o |  3 draft D
   | |
   o |  2 public C
   |/
   o  1 public B
   |
   o  0 public A
   
 
 move changeset backward
 
 (without -r option)
 
   $ hg phase --draft --force 2
   test-debug-phase: move rev 2: 0 -> 1
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:  public -> draft
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    7 secret merge B' and E
   |\
   | o  6 draft B'
   | |
   +---o  5 secret H
   | |
   o |  4 secret E
   | |
   o |  3 draft D
   | |
   o |  2 draft C
   |/
   o  1 public B
   |
   o  0 public A
   
 
 move changeset forward and backward
 
   $ hg phase --draft --force 1::4
   test-debug-phase: move rev 1: 0 -> 1
   test-debug-phase: move rev 4: 2 -> 1
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:  public -> draft
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:  secret -> draft
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    7 secret merge B' and E
   |\
   | o  6 draft B'
   | |
   +---o  5 secret H
   | |
   o |  4 draft E
   | |
   o |  3 draft D
   | |
   o |  2 draft C
   |/
   o  1 draft B
   |
   o  0 public A
   
 test partial failure
 
   $ hg phase --public 7
   test-debug-phase: move rev 1: 1 -> 0
   test-debug-phase: move rev 2: 1 -> 0
   test-debug-phase: move rev 3: 1 -> 0
   test-debug-phase: move rev 4: 1 -> 0
   test-debug-phase: move rev 6: 1 -> 0
   test-debug-phase: move rev 7: 2 -> 0
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:  draft -> public
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:  draft -> public
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:  draft -> public
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:  draft -> public
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:  draft -> public
   test-hook-close-phase: 17a481b3bccb796c0521ae97903d81c52bfee4af:  secret -> public
   $ hg phase --draft '5 or 7'
   test-debug-phase: move rev 5: 2 -> 1
   test-hook-close-phase: a030c6be5127abc010fcbff1851536552e6951a8:  secret -> draft
   cannot move 1 changesets to a higher phase, use --force
   phase changed for 1 changesets
   [1]
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    7 public merge B' and E
   |\
   | o  6 public B'
   | |
   +---o  5 draft H
   | |
   o |  4 public E
   | |
   o |  3 public D
   | |
   o |  2 public C
   |/
   o  1 public B
   |
   o  0 public A
   
 
 test complete failure
 
   $ hg phase --draft 7
   cannot move 1 changesets to a higher phase, use --force
   no phases changed
   [1]
 
   $ cd ..
 
 test hidden changeset are not cloned as public (issue3935)
 
   $ cd initialrepo
 
 (enabling evolution)
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 
 (making a changeset hidden; H in that case)
   $ hg debugobsolete `hg id --debug -r 5`
   1 new obsolescence markers
   obsoleted 1 changesets
 
   $ cd ..
   $ hg clone initialrepo clonewithobs
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 7 changesets with 6 changes to 6 files
   new changesets 4a2df7238c3b:17a481b3bccb
   test-debug-phase: new rev 0:  x -> 0
   test-debug-phase: new rev 1:  x -> 0
   test-debug-phase: new rev 2:  x -> 0
   test-debug-phase: new rev 3:  x -> 0
   test-debug-phase: new rev 4:  x -> 0
   test-debug-phase: new rev 5:  x -> 0
   test-debug-phase: new rev 6:  x -> 0
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> public
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> public
   test-hook-close-phase: f838bfaca5c7226600ebcfd84f3c3c13a28d3757:   -> public
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:   -> public
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:   -> public
   test-hook-close-phase: cf9fe039dfd67e829edf6522a45de057b5c86519:   -> public
   test-hook-close-phase: 17a481b3bccb796c0521ae97903d81c52bfee4af:   -> public
   updating to branch default
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd clonewithobs
   $ hg log -G --template "{rev} {phase} {desc}\n"
   @    6 public merge B' and E
   |\
   | o  5 public B'
   | |
   o |  4 public E
   | |
   o |  3 public D
   | |
   o |  2 public C
   |/
   o  1 public B
   |
   o  0 public A
   
 
 test verify repo containing hidden changesets, which should not abort just
 because repo.cancopy() is False
 
   $ cd ../initialrepo
   $ hg verify -q
 
   $ cd ..
 
 check whether HG_PENDING makes pending changes only in related
 repositories visible to an external hook.
 
 (emulate a transaction running concurrently by copied
 .hg/phaseroots.pending in subsequent test)
 
   $ cat > $TESTTMP/savepending.sh <<EOF
   > cp .hg/store/phaseroots.pending  .hg/store/phaseroots.pending.saved
   > exit 1 # to avoid changing phase for subsequent tests
   > EOF
   $ cd push-dest
   $ hg phase 6
   6: draft
   $ hg --config hooks.pretxnclose="sh $TESTTMP/savepending.sh" phase -f -s 6
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
   $ cp .hg/store/phaseroots.pending.saved .hg/store/phaseroots.pending
 
 (check (in)visibility of phaseroot while transaction running in repo)
 
   $ cat > $TESTTMP/checkpending.sh <<EOF
   > echo '@initialrepo'
   > hg -R "$TESTTMP/initialrepo" phase 7
   > echo '@push-dest'
   > hg -R "$TESTTMP/push-dest" phase 6
   > exit 1 # to avoid changing phase for subsequent tests
   > EOF
   $ cd ../initialrepo
   $ hg phase 7
   7: public
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkpending.sh" phase -f -s 7
   @initialrepo
   7: secret
   @push-dest
   6: draft
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
 
 Check that pretxnclose-phase hook can control phase movement
 
   $ hg phase --force b3325c91a4d9 --secret
   test-debug-phase: move rev 3: 0 -> 2
   test-debug-phase: move rev 4: 0 -> 2
   test-debug-phase: move rev 5: 1 -> 2
   test-debug-phase: move rev 7: 0 -> 2
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:  public -> secret
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:  public -> secret
   test-hook-close-phase: a030c6be5127abc010fcbff1851536552e6951a8:  draft -> secret
   test-hook-close-phase: 17a481b3bccb796c0521ae97903d81c52bfee4af:  public -> secret
   $ hg log -G -T phases
   @    changeset:   7:17a481b3bccb
   |\   tag:         tip
   | |  phase:       secret
   | |  parent:      6:cf9fe039dfd6
   | |  parent:      4:a603bfb5a83e
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     merge B' and E
   | |
   | o  changeset:   6:cf9fe039dfd6
   | |  phase:       public
   | |  parent:      1:27547f69f254
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     B'
   | |
   o |  changeset:   4:a603bfb5a83e
   | |  phase:       secret
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     E
   | |
   o |  changeset:   3:b3325c91a4d9
   | |  phase:       secret
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     D
   | |
   o |  changeset:   2:f838bfaca5c7
   |/   phase:       public
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     C
   |
   o  changeset:   1:27547f69f254
   |  phase:       public
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     B
   |
   o  changeset:   0:4a2df7238c3b
      phase:       public
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A
   
 
 Install a hook that prevent b3325c91a4d9 to become public
 
   $ cat >> .hg/hgrc << EOF
   > [hooks]
   > pretxnclose-phase.nopublish_D = sh -c "(echo \$HG_NODE| grep -v b3325c91a4d9>/dev/null) || [ 'public' != \$HG_PHASE ]"
   > EOF
 
 Try various actions. only the draft move should succeed
 
   $ hg phase --public b3325c91a4d9
-  transaction abort!
-  rollback completed
   abort: pretxnclose-phase.nopublish_D hook exited with status 1
   [40]
   $ hg phase --public a603bfb5a83e
-  transaction abort!
-  rollback completed
   abort: pretxnclose-phase.nopublish_D hook exited with status 1
   [40]
   $ hg phase --draft 17a481b3bccb
   test-debug-phase: move rev 3: 2 -> 1
   test-debug-phase: move rev 4: 2 -> 1
   test-debug-phase: move rev 7: 2 -> 1
   test-hook-close-phase: b3325c91a4d916bcc4cdc83ea3fe4ece46a42f6e:  secret -> draft
   test-hook-close-phase: a603bfb5a83e312131cebcd05353c217d4d21dde:  secret -> draft
   test-hook-close-phase: 17a481b3bccb796c0521ae97903d81c52bfee4af:  secret -> draft
   $ hg phase --public 17a481b3bccb
-  transaction abort!
-  rollback completed
   abort: pretxnclose-phase.nopublish_D hook exited with status 1
   [40]
 
   $ cd ..
 
 Test for the "internal" phase
 =============================
 
 Check we deny its usage on older repository
 
   $ hg init no-internal-phase --config format.use-internal-phase=no
   $ cd no-internal-phase
   $ hg debugrequires | grep internal-phase
   [1]
   $ echo X > X
   $ hg add X
   $ hg status
   A X
   $ hg --config "phases.new-commit=internal" commit -m "my test internal commit" 2>&1 | grep ProgrammingError
   ** ProgrammingError: this repository does not support the internal phase
       raise error.ProgrammingError(msg) (no-pyoxidizer !)
   *ProgrammingError: this repository does not support the internal phase (glob)
   $ hg --config "phases.new-commit=archived" commit -m "my test archived commit" 2>&1 | grep ProgrammingError
   ** ProgrammingError: this repository does not support the archived phase
       raise error.ProgrammingError(msg) (no-pyoxidizer !)
   *ProgrammingError: this repository does not support the archived phase (glob)
 
   $ cd ..
 
 Check it works fine with repository that supports it.
 
   $ hg init internal-phase --config format.use-internal-phase=yes
   $ cd internal-phase
   $ hg debugrequires | grep internal-phase
   internal-phase-2
   $ mkcommit A
   test-debug-phase: new rev 0:  x -> 1
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> draft
 
 Commit an internal changesets
 
   $ echo B > B
   $ hg add B
   $ hg status
   A B
   $ hg --config "phases.new-commit=internal" commit -m "my test internal commit"
   test-debug-phase: new rev 1:  x -> 96
   test-hook-close-phase: c01c42dffc7f81223397e99652a0703f83e1c5ea:   -> internal
 
 The changeset is a working parent descendant.
 Per the usual visibility rules, it is made visible.
 
   $ hg log -G -l 3
   @  changeset:   1:c01c42dffc7f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     my test internal commit
   |
   o  changeset:   0:4a2df7238c3b
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A
   
 
 Commit is hidden as expected
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   @  changeset:   0:4a2df7238c3b
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A
   
 
 Test for archived phase
 -----------------------
 
 Commit an archived changesets
 
   $ cd ..
   $ hg clone --quiet --pull internal-phase archived-phase \
   > --config format.exp-archived-phase=yes \
   > --config extensions.phasereport='!' \
   > --config hooks.txnclose-phase.test=
 
   $ cd archived-phase
 
   $ echo B > B
   $ hg add B
   $ hg status
   A B
   $ hg --config "phases.new-commit=archived" commit -m "my test archived commit"
   test-debug-phase: new rev 1:  x -> 32
   test-hook-close-phase: 8df5997c3361518f733d1ae67cd3adb9b0eaf125:   -> archived
 
 The changeset is a working parent descendant.
 Per the usual visibility rules, it is made visible.
 
   $ hg log -G -l 3
   @  changeset:   1:8df5997c3361
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     my test archived commit
   |
   o  changeset:   0:4a2df7238c3b
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A
   
 
 Commit is hidden as expected
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -G
   @  changeset:   0:4a2df7238c3b
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     A
   
   $ cd ..
 
 Recommitting an exact match of a public commit shouldn't change it to
 draft:
 
   $ cd initialrepo
   $ hg phase -r 2
   2: public
   $ hg up -C 1
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ mkcommit C
   warning: commit already existed in the repository!
   $ hg phase -r 2
   2: public
 
 Same, but for secret:
 
   $ hg up 7
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkcommit F -s
   test-debug-phase: new rev 8:  x -> 2
   test-hook-close-phase: de414268ec5ce2330c590b942fbb5ff0b0ca1a0a:   -> secret
   $ hg up 7
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg phase
   7: draft
   $ mkcommit F
   test-debug-phase: new rev 8:  x -> 2
   warning: commit already existed in the repository!
   test-hook-close-phase: de414268ec5ce2330c590b942fbb5ff0b0ca1a0a:   -> secret
   $ hg phase -r tip
   8: secret
 
 But what about obsoleted changesets?
 
   $ hg up 4
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ mkcommit H
   test-debug-phase: new rev 5:  x -> 2
   warning: commit already existed in the repository!
   test-hook-close-phase: a030c6be5127abc010fcbff1851536552e6951a8:   -> secret
   $ hg phase -r 5
   5: secret
   $ hg par
   changeset:   5:a030c6be5127
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   obsolete:    pruned
   summary:     H
   
   $ hg up tip
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ cd ..
 
 Testing that command line flags override configuration
 
   $ hg init commit-overrides
   $ cd commit-overrides
 
 `hg commit --draft` overrides new-commit=secret
 
   $ mkcommit A --config phases.new-commit='secret' --draft
   test-debug-phase: new rev 0:  x -> 1
   test-hook-close-phase: 4a2df7238c3b48766b5e22fafbb8a2f506ec8256:   -> draft
   $ hglog
   @  0 1 A
   
 
 `hg commit --secret` overrides new-commit=draft
 
   $ mkcommit B --config phases.new-commit='draft' --secret
   test-debug-phase: new rev 1:  x -> 2
   test-hook-close-phase: 27547f69f25460a52fff66ad004e58da7ad3fb56:   -> secret
   $ hglog
   @  1 2 B
   |
   o  0 1 A
   
 
   $ cd ..

tests/test-rebase-transaction.t

@@ -1,204 +1,202 b''
 #testcases continuecommand continueflag
 Rebasing using a single transaction
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [rebase]
   > singletransaction=True
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {desc}"
   > EOF
 
 #if continueflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > continue = rebase --continue
   > EOF
 #endif
 
 Check that a simple rebase works
 
   $ hg init simple && cd simple
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
 - We should only see one status stored message. It comes from the start.
   $ hg rebase --debug -b D -d Z | grep 'status stored'
   rebase status stored
   $ hg tglog
   o  5: D
   |
   o  4: C
   |
   o  3: B
   |
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 Check that --collapse works
 
   $ hg init collapse && cd collapse
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
 - We should only see two status stored messages. One from the start, one from
 - cmdutil.commitforceeditor() which forces tr.writepending()
   $ hg rebase --collapse --debug -b D -d Z | grep 'status stored'
   rebase status stored
   rebase status stored
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 With --collapse, check that conflicts can be resolved and rebase can then be
 continued
 
   $ hg init collapse-conflict && cd collapse-conflict
   $ hg debugdrawdag <<'EOF'
   >   Z   # Z/conflict=Z
   >   |
   >   | D
   >   | |
   >   | C # C/conflict=C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
   $ hg rebase --collapse -b D -d Z
   rebasing 1:112478962961 B "B"
   rebasing 3:c26739dbe603 C "C"
   merging conflict
   warning: conflicts while merging conflict! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
   $ hg tglog
   o  5: D
   |
   | @  4: Z
   | |
   % |  3: C
   | |
   | o  2: Y
   | |
   o |  1: B
   |/
   o  0: A
   
   $ hg st
   M conflict
   A B
   A C
   ? conflict.orig
   $ echo resolved > conflict
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg continue
   already rebased 1:112478962961 B "B" as 79bc8f4973ce
   rebasing 3:c26739dbe603 C "C"
   rebasing 5:d24bb333861c D tip "D"
   saved backup bundle to $TESTTMP/collapse-conflict/.hg/strip-backup/112478962961-b5b34645-rebase.hg
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..
 
 With --collapse, check that the commit message editing can be canceled and
 rebase can then be continued
 
   $ hg init collapse-cancel-editor && cd collapse-cancel-editor
   $ hg debugdrawdag <<'EOF'
   >   Z
   >   |
   >   | D
   >   | |
   >   | C
   >   | |
   >   Y B
   >   |/
   >   A
   > EOF
   $ HGEDITOR=false hg --config ui.interactive=1 rebase --collapse -b D -d Z
   rebasing 1:112478962961 B "B"
   rebasing 3:26805aba1e60 C "C"
   rebasing 5:f585351a92f8 D tip "D"
-  transaction abort!
-  rollback completed
   abort: edit failed: false exited with status 1
   [250]
   $ hg tglog
   o  5: D
   |
   | o  4: Z
   | |
   o |  3: C
   | |
   | o  2: Y
   | |
   o |  1: B
   |/
   o  0: A
   
   $ hg continue
   rebasing 1:112478962961 B "B"
   rebasing 3:26805aba1e60 C "C"
   rebasing 5:f585351a92f8 D tip "D"
   saved backup bundle to $TESTTMP/collapse-cancel-editor/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
   $ hg tglog
   o  3: Collapsed revision
   |  * B
   |  * C
   |  * D
   o  2: Z
   |
   o  1: Y
   |
   o  0: A
   
   $ cd ..

tests/test-share-bookmarks.t

@@ -1,292 +1,288 b''
 #testcases vfs svfs
 #testcases safe normal
 
 #if safe
   $ echo "[format]"         >> $HGRCPATH
   $ echo "use-share-safe = True" >> $HGRCPATH
 #endif
 
   $ echo "[extensions]"      >> $HGRCPATH
   $ echo "share = "          >> $HGRCPATH
 
 #if svfs
   $ echo "[format]"                  >> $HGRCPATH
   $ echo "bookmarks-in-store = yes " >> $HGRCPATH
 #endif
 
 prepare repo1
 
   $ hg init repo1
   $ cd repo1
   $ echo a > a
   $ hg commit -A -m'init'
   adding a
   $ echo a >> a
   $ hg commit -m'change in shared clone'
   $ echo b > b
   $ hg commit -A -m'another file'
   adding b
 
 share it
 
   $ cd ..
   $ hg share repo1 repo2
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 test sharing bookmarks
 
   $ hg share -B repo1 repo3
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo1
   $ hg bookmark bm1
   $ hg bookmarks
    * bm1                       2:c2e0ac586386
   $ cd ../repo2
   $ hg book bm2
   $ hg bookmarks
      bm1                       2:c2e0ac586386 (svfs !)
    * bm2                       2:c2e0ac586386
   $ cd ../repo3
   $ hg bookmarks
      bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
   $ hg book bm3
   $ hg bookmarks
      bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
    * bm3                       2:c2e0ac586386
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
      bm3                       2:c2e0ac586386
 
 check whether HG_PENDING makes pending changes only in relatd
 repositories visible to an external hook.
 
 In "hg share" case, another transaction can't run in other
 repositories sharing same source repository, because starting
 transaction requires locking store of source repository.
 
 Therefore, this test scenario ignores checking visibility of
 .hg/bookmarks.pending in repo2, which shares repo1 without bookmarks.
 
   $ cat > $TESTTMP/checkbookmarks.sh <<EOF
   > echo "@repo1"
   > hg -R "$TESTTMP/repo1" bookmarks
   > echo "@repo2"
   > hg -R "$TESTTMP/repo2" bookmarks
   > echo "@repo3"
   > hg -R "$TESTTMP/repo3" bookmarks
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ cd ../repo1
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
   @repo1
      bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
      bm3                       2:c2e0ac586386
    * bmX                       2:c2e0ac586386
   @repo2
      bm1                       2:c2e0ac586386 (svfs !)
    * bm2                       2:c2e0ac586386
      bm3                       2:c2e0ac586386 (svfs !)
   @repo3
      bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
    * bm3                       2:c2e0ac586386
      bmX                       2:c2e0ac586386 (vfs !)
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
   $ hg book bm1
 
 FYI, in contrast to above test, bmX is invisible in repo1 (= shared
 src), because (1) HG_PENDING refers only repo3 and (2)
 "bookmarks.pending" is written only into repo3.
 
   $ cd ../repo3
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
   @repo1
    * bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
      bm3                       2:c2e0ac586386
   @repo2
      bm1                       2:c2e0ac586386 (svfs !)
    * bm2                       2:c2e0ac586386
      bm3                       2:c2e0ac586386 (svfs !)
   @repo3
      bm1                       2:c2e0ac586386
      bm2                       2:c2e0ac586386 (svfs !)
      bm3                       2:c2e0ac586386
    * bmX                       2:c2e0ac586386
-  transaction abort!
-  rollback completed
   abort: pretxnclose hook exited with status 1
   [40]
   $ hg book bm3
 
 clean up bm2 since it's uninteresting (not shared in the vfs case and
 same as bm3 in the svfs case)
   $ cd ../repo2
   $ hg book -d bm2
 
   $ cd ../repo1
 
 test that commits work
 
   $ echo 'shared bookmarks' > a
   $ hg commit -m 'testing shared bookmarks'
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       2:c2e0ac586386
   $ cd ../repo3
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       2:c2e0ac586386
   $ echo 'more shared bookmarks' > a
   $ hg commit -m 'testing shared bookmarks'
   created new head
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
   $ cd ..
 
 test pushing bookmarks works
 
   $ hg clone repo3 repo4
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo4
   $ hg boo bm4
   $ echo foo > b
   $ hg commit -m 'foo in b'
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm4                       5:92793bfc8cad
   $ hg push -B bm4
   pushing to $TESTTMP/repo3
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   exporting bookmark bm4
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 test behavior when sharing a shared repo
 
   $ hg share -B repo3 missingdir/repo5
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd missingdir/repo5
   $ hg book
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ../..
 
 test what happens when an active bookmark is deleted
 
   $ cd repo1
   $ hg boo -d bm3
   $ hg boo
    * bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ cd ..
 
 verify that bookmarks are not written on failed transaction
 
   $ cat > failpullbookmarks.py << EOF
   > """A small extension that makes bookmark pulls fail, for testing"""
   > from mercurial import (
   >   error,
   >   exchange,
   >   extensions,
   > )
   > def _pullbookmarks(orig, pullop):
   >     orig(pullop)
   >     raise error.HookAbort(b'forced failure by extension')
   > def extsetup(ui):
   >     extensions.wrapfunction(exchange, '_pullbookmarks', _pullbookmarks)
   > EOF
   $ cd repo4
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ hg --config "extensions.failpullbookmarks=$TESTTMP/failpullbookmarks.py" pull $TESTTMP/repo4
   pulling from $TESTTMP/repo4
   searching for changes
   no changes found
   adding remote bookmark bm3
   abort: forced failure by extension
   [40]
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ hg pull $TESTTMP/repo4
   pulling from $TESTTMP/repo4
   searching for changes
   no changes found
   adding remote bookmark bm3
   1 local changesets published
   $ hg boo
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 verify bookmark behavior after unshare
 
   $ cd repo3
   $ hg unshare
   $ hg boo
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ hg boo -d bm4
   $ hg boo bm5
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm5                       4:62f4ded848e4
   $ cd ../repo1
   $ hg boo
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 Test that if store is disabled, we drop the bookmarksinstore requirement
 
   $ hg init brokenrepo --config format.bookmarks-in-store=True --config format.usestore=false
   ignoring enabled 'format.bookmarks-in-store' config beacuse it is incompatible with disabled 'format.usestore' config
   ignoring enabled 'format.use-share-safe' config because it is incompatible with disabled 'format.usestore' config (safe !)

tests/test-split.t

@@ -1,1148 +1,1146 b''
 #testcases obsstore-on obsstore-off
 
   $ cat > $TESTTMP/editor.py <<EOF
   > #!"$PYTHON"
   > import os
   > import sys
   > path = os.path.join(os.environ['TESTTMP'], 'messages')
   > messages = open(path).read().split('--\n')
   > prompt = open(sys.argv[1]).read()
   > sys.stdout.write(''.join('EDITOR: %s' % l for l in prompt.splitlines(True)))
   > sys.stdout.flush()
   > with open(sys.argv[1], 'w') as f:
   >    f.write(messages[0])
   > with open(path, 'w') as f:
   >    f.write('--\n'.join(messages[1:]))
   > EOF
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > drawdag=$TESTDIR/drawdag.py
   > split=
   > [ui]
   > interactive=1
   > color=no
   > paginate=never
   > [diff]
   > git=1
   > unified=0
   > [commands]
   > commit.interactive.unified=0
   > [alias]
   > glog=log -G -T '{rev}:{node|short} {desc} {bookmarks}\n'
   > EOF
 
 #if obsstore-on
   $ cat >> $HGRCPATH <<EOF
   > [experimental]
   > evolution=all
   > EOF
 #endif
 
   $ hg init a
   $ cd a
 
 Nothing to split
 
   $ hg split
   nothing to split
   [1]
 
   $ hg commit -m empty --config ui.allowemptycommit=1
   $ hg split
   abort: cannot split an empty revision
   [10]
 
   $ rm -rf .hg
   $ hg init
 
 Cannot split working directory
 
   $ hg split -r 'wdir()'
   abort: cannot split working directory
   [10]
 
 Generate some content.  The sed filter drop CR on Windows, which is dropped in
 the a > b line.
 
   $ $TESTDIR/seq.py 1 5 | sed 's/\r$//' >> a
   $ hg ci -m a1 -A a -q
   $ hg bookmark -i r1
   $ sed 's/1/11/;s/3/33/;s/5/55/' a > b
   $ mv b a
   $ hg ci -m a2 -q
   $ hg bookmark -i r2
 
 Cannot split a public changeset
 
   $ hg phase --public -r 'all()'
   $ hg split .
   abort: cannot split public changesets: 1df0d5c5a3ab
   (see 'hg help phases' for details)
   [10]
 
   $ hg phase --draft -f -r 'all()'
 
 Cannot split while working directory is dirty
 
   $ touch dirty
   $ hg add dirty
   $ hg split .
   abort: uncommitted changes
   [20]
   $ hg forget dirty
   $ rm dirty
 
 Make a clean directory for future tests to build off of
 
   $ cp -R . ../clean
 
 Split a head
 
   $ hg bookmark r3
 
   $ hg split 'all()'
   abort: cannot split multiple revisions
   [10]
 
 This function splits a bit strangely primarily to avoid changing the behavior of
 the test after a bug was fixed with how split/commit --interactive handled
 `commands.commit.interactive.unified=0`: when there were no context lines,
 it kept only the last diff hunk. When running split, this meant that runsplit
 was always recording three commits, one for each diff hunk, in reverse order
 (the base commit was the last diff hunk in the file).
   $ runsplit() {
   > cat > $TESTTMP/messages <<EOF
   > split 1
   > --
   > split 2
   > --
   > split 3
   > EOF
   > cat <<EOF | hg split "$@"
   > y
   > n
   > n
   > y
   > y
   > n
   > y
   > y
   > y
   > EOF
   > }
 
   $ HGEDITOR=false runsplit
   diff --git a/a b/a
   3 hunks, 3 lines changed
   examine changes to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,1 @@
   -1
   +11
   record change 1/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -3,1 +3,1 @@ 2
   -3
   +33
   record change 2/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -5,1 +5,1 @@ 4
   -5
   +55
   record change 3/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
-  transaction abort!
-  rollback completed
   abort: edit failed: false exited with status 1
   [250]
   $ hg status
 
   $ HGEDITOR="\"$PYTHON\" $TESTTMP/editor.py"
   $ runsplit
   diff --git a/a b/a
   3 hunks, 3 lines changed
   examine changes to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,1 @@
   -1
   +11
   record change 1/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -3,1 +3,1 @@ 2
   -3
   +33
   record change 2/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -5,1 +5,1 @@ 4
   -5
   +55
   record change 3/3 to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   EDITOR: HG: Splitting 1df0d5c5a3ab. Write commit message for the first split changeset.
   EDITOR: a2
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed a
   created new head
   diff --git a/a b/a
   2 hunks, 2 lines changed
   examine changes to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,1 @@
   -1
   +11
   record change 1/2 to 'a'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -3,1 +3,1 @@ 2
   -3
   +33
   record change 2/2 to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   EDITOR: HG: Splitting 1df0d5c5a3ab. So far it has been split into:
   EDITOR: HG: - 2:e704349bd21b tip "split 1"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: a2
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed a
   diff --git a/a b/a
   1 hunks, 1 lines changed
   examine changes to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,1 +1,1 @@
   -1
   +11
   record this change to 'a'?
   (enter ? for help) [Ynesfdaq?] y
   
   EDITOR: HG: Splitting 1df0d5c5a3ab. So far it has been split into:
   EDITOR: HG: - 2:e704349bd21b tip "split 1"
   EDITOR: HG: - 3:a09ad58faae3 "split 2"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: a2
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed a
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/1df0d5c5a3ab-8341b760-split.hg (obsstore-off !)
 
 #if obsstore-off
   $ hg bookmark
      r1                        0:a61bcde8c529
      r2                        3:00eebaf8d2e2
    * r3                        3:00eebaf8d2e2
   $ hg glog -p
   @  3:00eebaf8d2e2 split 3 r2 r3
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -1,1 +1,1 @@
   |  -1
   |  +11
   |
   o  2:a09ad58faae3 split 2
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -3,1 +3,1 @@
   |  -3
   |  +33
   |
   o  1:e704349bd21b split 1
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -5,1 +5,1 @@
   |  -5
   |  +55
   |
   o  0:a61bcde8c529 a1 r1
      diff --git a/a b/a
      new file mode 100644
      --- /dev/null
      +++ b/a
      @@ -0,0 +1,5 @@
      +1
      +2
      +3
      +4
      +5
   
 #else
   $ hg bookmark
      r1                        0:a61bcde8c529
      r2                        4:00eebaf8d2e2
    * r3                        4:00eebaf8d2e2
   $ hg glog
   @  4:00eebaf8d2e2 split 3 r2 r3
   |
   o  3:a09ad58faae3 split 2
   |
   o  2:e704349bd21b split 1
   |
   o  0:a61bcde8c529 a1 r1
   
 #endif
 
 Split a head while working parent is not that head
 
   $ cp -R $TESTTMP/clean $TESTTMP/b
   $ cd $TESTTMP/b
 
   $ hg up 0 -q
   $ hg bookmark r3
 
   $ runsplit tip >/dev/null
 
 #if obsstore-off
   $ hg bookmark
      r1                        0:a61bcde8c529
      r2                        3:00eebaf8d2e2
    * r3                        0:a61bcde8c529
   $ hg glog
   o  3:00eebaf8d2e2 split 3 r2
   |
   o  2:a09ad58faae3 split 2
   |
   o  1:e704349bd21b split 1
   |
   @  0:a61bcde8c529 a1 r1 r3
   
 #else
   $ hg bookmark
      r1                        0:a61bcde8c529
      r2                        4:00eebaf8d2e2
    * r3                        0:a61bcde8c529
   $ hg glog
   o  4:00eebaf8d2e2 split 3 r2
   |
   o  3:a09ad58faae3 split 2
   |
   o  2:e704349bd21b split 1
   |
   @  0:a61bcde8c529 a1 r1 r3
   
 #endif
 
 Split a non-head
 
   $ cp -R $TESTTMP/clean $TESTTMP/c
   $ cd $TESTTMP/c
   $ echo d > d
   $ hg ci -m d1 -A d
   $ hg bookmark -i d1
   $ echo 2 >> d
   $ hg ci -m d2
   $ echo 3 >> d
   $ hg ci -m d3
   $ hg bookmark -i d3
   $ hg up '.^' -q
   $ hg bookmark d2
   $ cp -R . ../d
 
   $ runsplit -r 1 | grep rebasing
   rebasing 2:b5c5ea414030 d1 "d1"
   rebasing 3:f4a0a8d004cc d2 "d2"
   rebasing 4:777940761eba d3 "d3"
 #if obsstore-off
   $ hg bookmark
      d1                        4:c4b449ef030e
    * d2                        5:c9dd00ab36a3
      d3                        6:19f476bc865c
      r1                        0:a61bcde8c529
      r2                        3:00eebaf8d2e2
   $ hg glog -p
   o  6:19f476bc865c d3 d3
   |  diff --git a/d b/d
   |  --- a/d
   |  +++ b/d
   |  @@ -2,0 +3,1 @@
   |  +3
   |
   @  5:c9dd00ab36a3 d2 d2
   |  diff --git a/d b/d
   |  --- a/d
   |  +++ b/d
   |  @@ -1,0 +2,1 @@
   |  +2
   |
   o  4:c4b449ef030e d1 d1
   |  diff --git a/d b/d
   |  new file mode 100644
   |  --- /dev/null
   |  +++ b/d
   |  @@ -0,0 +1,1 @@
   |  +d
   |
   o  3:00eebaf8d2e2 split 3 r2
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -1,1 +1,1 @@
   |  -1
   |  +11
   |
   o  2:a09ad58faae3 split 2
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -3,1 +3,1 @@
   |  -3
   |  +33
   |
   o  1:e704349bd21b split 1
   |  diff --git a/a b/a
   |  --- a/a
   |  +++ b/a
   |  @@ -5,1 +5,1 @@
   |  -5
   |  +55
   |
   o  0:a61bcde8c529 a1 r1
      diff --git a/a b/a
      new file mode 100644
      --- /dev/null
      +++ b/a
      @@ -0,0 +1,5 @@
      +1
      +2
      +3
      +4
      +5
   
 #else
   $ hg bookmark
      d1                        8:c4b449ef030e
    * d2                        9:c9dd00ab36a3
      d3                        10:19f476bc865c
      r1                        0:a61bcde8c529
      r2                        7:00eebaf8d2e2
   $ hg glog
   o  10:19f476bc865c d3 d3
   |
   @  9:c9dd00ab36a3 d2 d2
   |
   o  8:c4b449ef030e d1 d1
   |
   o  7:00eebaf8d2e2 split 3 r2
   |
   o  6:a09ad58faae3 split 2
   |
   o  5:e704349bd21b split 1
   |
   o  0:a61bcde8c529 a1 r1
   
 #endif
 
 Split a non-head without rebase
 
   $ cd $TESTTMP/d
 #if obsstore-off
   $ runsplit -r 1 --no-rebase
   abort: cannot split changeset, as that will orphan 3 descendants
   (see 'hg help evolution.instability')
   [10]
 #else
   $ runsplit -r 1 --no-rebase >/dev/null
   3 new orphan changesets
   $ hg bookmark
      d1                        2:b5c5ea414030
    * d2                        3:f4a0a8d004cc
      d3                        4:777940761eba
      r1                        0:a61bcde8c529
      r2                        7:00eebaf8d2e2
 
   $ hg glog
   o  7:00eebaf8d2e2 split 3 r2
   |
   o  6:a09ad58faae3 split 2
   |
   o  5:e704349bd21b split 1
   |
   | *  4:777940761eba d3 d3
   | |
   | @  3:f4a0a8d004cc d2 d2
   | |
   | *  2:b5c5ea414030 d1 d1
   | |
   | x  1:1df0d5c5a3ab a2
   |/
   o  0:a61bcde8c529 a1 r1
   
 #endif
 
 Split a non-head with obsoleted descendants
 
 #if obsstore-on
   $ hg init $TESTTMP/e
   $ cd $TESTTMP/e
   $ hg debugdrawdag <<'EOS'
   >   H I   J
   >   | |   |
   >   F G1 G2  # amend: G1 -> G2
   >   | |  /   # prune: F
   >   C D E
   >    \|/
   >     B
   >     |
   >     A
   > EOS
   2 new orphan changesets
   $ eval `hg tags -T '{tag}={node}\n'`
   $ rm .hg/localtags
   $ hg split $B --config experimental.evolution=createmarkers
   abort: cannot split changeset, as that will orphan 4 descendants
   (see 'hg help evolution.instability')
   [10]
   $ cat > $TESTTMP/messages <<EOF
   > Split B
   > EOF
   $ cat <<EOF | hg split $B
   > y
   > y
   > EOF
   diff --git a/B b/B
   new file mode 100644
   examine changes to 'B'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,1 @@
   +B
   \ No newline at end of file
   record this change to 'B'?
   (enter ? for help) [Ynesfdaq?] y
   
   EDITOR: HG: Splitting 112478962961. Write commit message for the first split changeset.
   EDITOR: B
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: added B
   created new head
   rebasing 2:26805aba1e60 "C"
   rebasing 3:be0ef73c17ad "D"
   rebasing 4:49cb92066bfd "E"
   rebasing 7:97a6268cc7ef "G2"
   rebasing 10:e2f1e425c0db "J"
   $ hg glog -r 'sort(all(), topo)'
   o  16:556c085f8b52 J
   |
   o  15:8761f6c9123f G2
   |
   o  14:a7aeffe59b65 E
   |
   | o  13:e1e914ede9ab D
   |/
   | o  12:01947e9b98aa C
   |/
   o  11:0947baa74d47 Split B
   |
   | *  9:88ede1d5ee13 I
   | |
   | x  6:af8cbf225b7b G1
   | |
   | x  3:be0ef73c17ad D
   | |
   | | *  8:74863e5b5074 H
   | | |
   | | x  5:ee481a2a1e69 F
   | | |
   | | x  2:26805aba1e60 C
   | |/
   | x  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
 #endif
 
 Preserve secret phase in split
 
   $ cp -R $TESTTMP/clean $TESTTMP/phases1
   $ cd $TESTTMP/phases1
   $ hg phase --secret -fr tip
   $ hg log -T '{short(node)} {phase}\n'
   1df0d5c5a3ab secret
   a61bcde8c529 draft
   $ runsplit tip >/dev/null
   $ hg log -T '{short(node)} {phase}\n'
   00eebaf8d2e2 secret
   a09ad58faae3 secret
   e704349bd21b secret
   a61bcde8c529 draft
 
 Do not move things to secret even if phases.new-commit=secret
 
   $ cp -R $TESTTMP/clean $TESTTMP/phases2
   $ cd $TESTTMP/phases2
   $ cat >> .hg/hgrc <<EOF
   > [phases]
   > new-commit=secret
   > EOF
   $ hg log -T '{short(node)} {phase}\n'
   1df0d5c5a3ab draft
   a61bcde8c529 draft
   $ runsplit tip >/dev/null
   $ hg log -T '{short(node)} {phase}\n'
   00eebaf8d2e2 draft
   a09ad58faae3 draft
   e704349bd21b draft
   a61bcde8c529 draft
 
 `hg split` with ignoreblanklines=1 does not infinite loop
 
   $ mkdir $TESTTMP/f
   $ hg init $TESTTMP/f/a
   $ cd $TESTTMP/f/a
   $ printf '1\n2\n3\n4\n5\n' > foo
   $ cp foo bar
   $ hg ci -qAm initial
   $ printf '1\n\n2\n3\ntest\n4\n5\n' > bar
   $ printf '1\n2\n3\ntest\n4\n5\n' > foo
   $ hg ci -qm splitme
   $ cat > $TESTTMP/messages <<EOF
   > split 1
   > --
   > split 2
   > EOF
   $ printf 'f\nn\nf\n' | hg --config extensions.split= --config diff.ignoreblanklines=1 split
   diff --git a/bar b/bar
   2 hunks, 2 lines changed
   examine changes to 'bar'?
   (enter ? for help) [Ynesfdaq?] f
   
   diff --git a/foo b/foo
   1 hunks, 1 lines changed
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] n
   
   EDITOR: HG: Splitting dd3c45017cbf. Write commit message for the first split changeset.
   EDITOR: splitme
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed bar
   created new head
   diff --git a/foo b/foo
   1 hunks, 1 lines changed
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] f
   
   EDITOR: HG: Splitting dd3c45017cbf. So far it has been split into:
   EDITOR: HG: - 2:f205aea1c624 tip "split 1"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: splitme
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed foo
   saved backup bundle to $TESTTMP/f/a/.hg/strip-backup/dd3c45017cbf-463441b5-split.hg (obsstore-off !)
 
 Let's try that again, with a slightly different set of patches, to ensure that
 the ignoreblanklines thing isn't somehow position dependent.
 
   $ hg init $TESTTMP/f/b
   $ cd $TESTTMP/f/b
   $ printf '1\n2\n3\n4\n5\n' > foo
   $ cp foo bar
   $ hg ci -qAm initial
   $ printf '1\n2\n3\ntest\n4\n5\n' > bar
   $ printf '1\n2\n3\ntest\n4\n\n5\n' > foo
   $ hg ci -qm splitme
   $ cat > $TESTTMP/messages <<EOF
   > split 1
   > --
   > split 2
   > EOF
   $ printf 'f\nn\nf\n' | hg --config extensions.split= --config diff.ignoreblanklines=1 split
   diff --git a/bar b/bar
   1 hunks, 1 lines changed
   examine changes to 'bar'?
   (enter ? for help) [Ynesfdaq?] f
   
   diff --git a/foo b/foo
   2 hunks, 2 lines changed
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] n
   
   EDITOR: HG: Splitting 904c80b40a4a. Write commit message for the first split changeset.
   EDITOR: splitme
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed bar
   created new head
   diff --git a/foo b/foo
   2 hunks, 2 lines changed
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] f
   
   EDITOR: HG: Splitting 904c80b40a4a. So far it has been split into:
   EDITOR: HG: - 2:ffecf40fa954 tip "split 1"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: splitme
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed foo
   saved backup bundle to $TESTTMP/f/b/.hg/strip-backup/904c80b40a4a-47fb907f-split.hg (obsstore-off !)
 
 
 Testing the case in split when commiting flag-only file changes (issue5864)
 ---------------------------------------------------------------------------
   $ hg init $TESTTMP/issue5864
   $ cd $TESTTMP/issue5864
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m "initial"
   $ hg import -q --bypass -m "make executable" - <<EOF
   > diff --git a/foo b/foo
   > old mode 100644
   > new mode 100755
   > EOF
   $ hg up -q
 
   $ hg glog
   @  1:3a2125f0f4cb make executable
   |
   o  0:51f273a58d82 initial
   
 
 #if no-windows
   $ cat > $TESTTMP/messages <<EOF
   > split 1
   > EOF
   $ printf 'y\n' | hg split
   diff --git a/foo b/foo
   old mode 100644
   new mode 100755
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] y
   
   EDITOR: HG: Splitting 3a2125f0f4cb. Write commit message for the first split changeset.
   EDITOR: make executable
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed foo
   created new head
   saved backup bundle to $TESTTMP/issue5864/.hg/strip-backup/3a2125f0f4cb-629e4432-split.hg (obsstore-off !)
 
   $ hg log -G -T "{node|short} {desc}\n"
   @  b154670c87da split 1
   |
   o  51f273a58d82 initial
   
 #else
 
 TODO: Fix this on Windows. See issue 2020 and 5883
 
   $ printf 'y\ny\ny\n' | hg split
   abort: cannot split an empty revision
   [10]
 #endif
 
 Test that splitting moves works properly (issue5723)
 ----------------------------------------------------
 
   $ hg init $TESTTMP/issue5723-mv
   $ cd $TESTTMP/issue5723-mv
   $ printf '1\n2\n' > file
   $ hg ci -qAm initial
   $ hg mv file file2
   $ printf 'a\nb\n1\n2\n3\n4\n' > file2
   $ cat > $TESTTMP/messages <<EOF
   > split1, keeping only the numbered lines
   > --
   > split2, keeping the lettered lines
   > EOF
   $ hg ci -m 'move and modify'
   $ printf 'y\nn\na\na\n' | hg split
   diff --git a/file b/file2
   rename from file
   rename to file2
   2 hunks, 4 lines changed
   examine changes to 'file' and 'file2'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,2 @@
   +a
   +b
   record change 1/2 to 'file2'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -2,0 +5,2 @@ 2
   +3
   +4
   record change 2/2 to 'file2'?
   (enter ? for help) [Ynesfdaq?] a
   
   EDITOR: HG: Splitting 8c42fa635116. Write commit message for the first split changeset.
   EDITOR: move and modify
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: added file2
   EDITOR: HG: removed file
   created new head
   diff --git a/file2 b/file2
   1 hunks, 2 lines changed
   examine changes to 'file2'?
   (enter ? for help) [Ynesfdaq?] a
   
   EDITOR: HG: Splitting 8c42fa635116. So far it has been split into:
   EDITOR: HG: - 2:478be2a70c27 tip "split1, keeping only the numbered lines"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: move and modify
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed file2
   saved backup bundle to $TESTTMP/issue5723-mv/.hg/strip-backup/8c42fa635116-a38044d4-split.hg (obsstore-off !)
   $ hg log -T '{desc}: {files%"{file} "}\n'
   split2, keeping the lettered lines: file2 
   split1, keeping only the numbered lines: file file2 
   initial: file 
   $ cat file2
   a
   b
   1
   2
   3
   4
   $ hg cat -r ".^" file2
   1
   2
   3
   4
   $ hg cat -r . file2
   a
   b
   1
   2
   3
   4
 
 
 Test that splitting copies works properly (issue5723)
 ----------------------------------------------------
 
   $ hg init $TESTTMP/issue5723-cp
   $ cd $TESTTMP/issue5723-cp
   $ printf '1\n2\n' > file
   $ hg ci -qAm initial
   $ hg cp file file2
   $ printf 'a\nb\n1\n2\n3\n4\n' > file2
 Also modify 'file' to prove that the changes aren't being pulled in
 accidentally.
   $ printf 'this is the new contents of "file"' > file
   $ cat > $TESTTMP/messages <<EOF
   > split1, keeping "file" and only the numbered lines in file2
   > --
   > split2, keeping the lettered lines in file2
   > EOF
   $ hg ci -m 'copy file->file2, modify both'
   $ printf 'f\ny\nn\na\na\n' | hg split
   diff --git a/file b/file
   1 hunks, 2 lines changed
   examine changes to 'file'?
   (enter ? for help) [Ynesfdaq?] f
   
   diff --git a/file b/file2
   copy from file
   copy to file2
   2 hunks, 4 lines changed
   examine changes to 'file' and 'file2'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -0,0 +1,2 @@
   +a
   +b
   record change 2/3 to 'file2'?
   (enter ? for help) [Ynesfdaq?] n
   
   @@ -2,0 +5,2 @@ 2
   +3
   +4
   record change 3/3 to 'file2'?
   (enter ? for help) [Ynesfdaq?] a
   
   EDITOR: HG: Splitting 41c861dfa61e. Write commit message for the first split changeset.
   EDITOR: copy file->file2, modify both
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: added file2
   EDITOR: HG: changed file
   created new head
   diff --git a/file2 b/file2
   1 hunks, 2 lines changed
   examine changes to 'file2'?
   (enter ? for help) [Ynesfdaq?] a
   
   EDITOR: HG: Splitting 41c861dfa61e. So far it has been split into:
   EDITOR: HG: - 2:4b19e06610eb tip "split1, keeping "file" and only the numbered lines in file2"
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: copy file->file2, modify both
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed file2
   saved backup bundle to $TESTTMP/issue5723-cp/.hg/strip-backup/41c861dfa61e-467e8d3c-split.hg (obsstore-off !)
   $ hg log -T '{desc}: {files%"{file} "}\n'
   split2, keeping the lettered lines in file2: file2 
   split1, keeping "file" and only the numbered lines in file2: file file2 
   initial: file 
   $ cat file2
   a
   b
   1
   2
   3
   4
   $ hg cat -r ".^" file2
   1
   2
   3
   4
   $ hg cat -r . file2
   a
   b
   1
   2
   3
   4
 
 Test that color codes don't end up in the commit message template
 ----------------------------------------------------
 
   $ hg init $TESTTMP/colorless
   $ cd $TESTTMP/colorless
   $ echo 1 > file1
   $ echo 1 > file2
   $ hg ci -qAm initial
   $ echo 2 > file1
   $ echo 2 > file2
   $ cat > $TESTTMP/messages <<EOF
   > split1, modifying file1
   > --
   > split2, modifying file2
   > EOF
   $ hg ci
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed file1
   EDITOR: HG: changed file2
   $ printf 'f\nn\na\n' | hg split --color=debug \
   > --config command-templates.oneline-summary='{label("rev", rev)} {desc}'
   [diff.diffline|diff --git a/file1 b/file1]
   1 hunks, 1 lines changed
   [ ui.prompt|examine changes to 'file1'?
   (enter ? for help) [Ynesfdaq?]] [ ui.promptecho|f]
   
   [diff.diffline|diff --git a/file2 b/file2]
   1 hunks, 1 lines changed
   [ ui.prompt|examine changes to 'file2'?
   (enter ? for help) [Ynesfdaq?]] [ ui.promptecho|n]
   
   EDITOR: HG: Splitting 6432c65c3078. Write commit message for the first split changeset.
   EDITOR: split1, modifying file1
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed file1
   [ ui.status|created new head]
   [diff.diffline|diff --git a/file2 b/file2]
   1 hunks, 1 lines changed
   [ ui.prompt|examine changes to 'file2'?
   (enter ? for help) [Ynesfdaq?]] [ ui.promptecho|a]
   
   EDITOR: HG: Splitting 6432c65c3078. So far it has been split into:
   EDITOR: HG: - 2 split2, modifying file2
   EDITOR: HG: Write commit message for the next split changeset.
   EDITOR: split1, modifying file1
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: changed file2
   [ ui.warning|transaction abort!]
   [ ui.warning|rollback completed]
   [ ui.error|abort: empty commit message]
   [10]
 
 Test that creating an empty split or "no-op"
 (identical to original) commit doesn't cause chaos
 --------------------------------------------------
 
   $ hg init $TESTTMP/noop
   $ cd $TESTTMP/noop
   $ echo r0 > r0
   $ hg ci -qAm r0
   $ hg phase -p
   $ echo foo > foo
   $ hg ci -qAm foo
   $ hg log -G -T'{phase} {rev}:{node|short} {desc}'
   @  draft 1:ae694b2901bb foo
   |
   o  public 0:222799e2f90b r0
   
   $ printf 'd\na\n' | HGEDITOR=cat hg split || true
   diff --git a/foo b/foo
   new file mode 100644
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] d
   
   no changes to record
   diff --git a/foo b/foo
   new file mode 100644
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] a
   
   HG: Splitting ae694b2901bb. Write commit message for the first split changeset.
   foo
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: added foo
   warning: commit already existed in the repository!
   $ hg log -G -T'{phase} {rev}:{node|short} {desc}'
   @  draft 1:ae694b2901bb foo
   |
   o  public 0:222799e2f90b r0
   
 
 Now try the same thing but modifying the message so we don't trigger the
 identical changeset failures
 
   $ hg init $TESTTMP/noop2
   $ cd $TESTTMP/noop2
   $ echo r0 > r0
   $ hg ci -qAm r0
   $ hg phase -p
   $ echo foo > foo
   $ hg ci -qAm foo
   $ hg log -G -T'{phase} {rev}:{node|short} {desc}'
   @  draft 1:ae694b2901bb foo
   |
   o  public 0:222799e2f90b r0
   
   $ cat > $TESTTMP/messages <<EOF
   > message1
   > EOF
   $ printf 'd\na\n' | HGEDITOR="\"$PYTHON\" $TESTTMP/editor.py" hg split
   diff --git a/foo b/foo
   new file mode 100644
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] d
   
   no changes to record
   diff --git a/foo b/foo
   new file mode 100644
   examine changes to 'foo'?
   (enter ? for help) [Ynesfdaq?] a
   
   EDITOR: HG: Splitting ae694b2901bb. Write commit message for the first split changeset.
   EDITOR: foo
   EDITOR: 
   EDITOR: 
   EDITOR: HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   EDITOR: HG: Leave message empty to abort commit.
   EDITOR: HG: --
   EDITOR: HG: user: test
   EDITOR: HG: branch 'default'
   EDITOR: HG: added foo
   created new head
   saved backup bundle to $TESTTMP/noop2/.hg/strip-backup/ae694b2901bb-28e0b457-split.hg (obsstore-off !)
   $ hg log -G -T'{phase} {rev}:{node|short} {desc}'
   @  draft 1:de675559d3f9 message1 (obsstore-off !)
   @  draft 2:de675559d3f9 message1 (obsstore-on !)
   |
   o  public 0:222799e2f90b r0
   
 #if obsstore-on
   $ hg debugobsolete
   ae694b2901bb8b0f8c4b5e075ddec0d63468d57a de675559d3f93ffc822c6eb7490e5c73033f17c7 0 * (glob)
 #endif