errors: raise more specific errors from rewriteutil

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

mercurial/rewriteutil.py

@@ -1,135 +1,135 b''
 # rewriteutil.py - utility functions for rewriting changesets
 #
 # Copyright 2017 Octobus <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import re
 
 from .i18n import _
 
 from . import (
     error,
     node,
     obsolete,
     obsutil,
     revset,
     scmutil,
 )
 
 
 NODE_RE = re.compile(br'\b[0-9a-f]{6,64}\b')
 
 
 def precheck(repo, revs, action=b'rewrite'):
     """check if revs can be rewritten
     action is used to control the error message.
 
     Make sure this function is called after taking the lock.
     """
     if node.nullrev in revs:
         msg = _(b"cannot %s null changeset") % action
         hint = _(b"no changeset checked out")
-        raise error.Abort(msg, hint=hint)
+        raise error.InputError(msg, hint=hint)
 
     if len(repo[None].parents()) > 1:
-        raise error.Abort(_(b"cannot %s while merging") % action)
+        raise error.StateError(_(b"cannot %s while merging") % action)
 
     publicrevs = repo.revs(b'%ld and public()', revs)
     if publicrevs:
         msg = _(b"cannot %s public changesets") % action
         hint = _(b"see 'hg help phases' for details")
-        raise error.Abort(msg, hint=hint)
+        raise error.InputError(msg, hint=hint)
 
     newunstable = disallowednewunstable(repo, revs)
     if newunstable:
-        raise error.Abort(_(b"cannot %s changeset with children") % action)
+        raise error.InputError(_(b"cannot %s changeset with children") % action)
 
 
 def disallowednewunstable(repo, revs):
     """Checks whether editing the revs will create new unstable changesets and
     are we allowed to create them.
 
     To allow new unstable changesets, set the config:
         `experimental.evolution.allowunstable=True`
     """
     allowunstable = obsolete.isenabled(repo, obsolete.allowunstableopt)
     if allowunstable:
         return revset.baseset()
     return repo.revs(b"(%ld::) - %ld", revs, revs)
 
 
 def skip_empty_successor(ui, command):
     empty_successor = ui.config(b'rewrite', b'empty-successor')
     if empty_successor == b'skip':
         return True
     elif empty_successor == b'keep':
         return False
     else:
         raise error.ConfigError(
             _(
                 b"%s doesn't know how to handle config "
                 b"rewrite.empty-successor=%s (only 'skip' and 'keep' are "
                 b"supported)"
             )
             % (command, empty_successor)
         )
 
 
 def update_hash_refs(repo, commitmsg, pending=None):
     """Replace all obsolete commit hashes in the message with the current hash.
 
     If the obsolete commit was split or is divergent, the hash is not replaced
     as there's no way to know which successor to choose.
 
     For commands that update a series of commits in the current transaction, the
     new obsolete markers can be considered by setting ``pending`` to a mapping
     of ``pending[oldnode] = [successor_node1, successor_node2,..]``.
     """
     if not pending:
         pending = {}
     cache = {}
     hashes = re.findall(NODE_RE, commitmsg)
     unfi = repo.unfiltered()
     for h in hashes:
         fullnode = scmutil.resolvehexnodeidprefix(unfi, h)
         if fullnode is None:
             continue
         ctx = unfi[fullnode]
         if not ctx.obsolete():
             successors = pending.get(fullnode)
             if successors is None:
                 continue
             # obsutil.successorssets() returns a list of list of nodes
             successors = [successors]
         else:
             successors = obsutil.successorssets(repo, ctx.node(), cache=cache)
 
         # We can't make any assumptions about how to update the hash if the
         # cset in question was split or diverged.
         if len(successors) == 1 and len(successors[0]) == 1:
             successor = successors[0][0]
             if successor is not None:
                 newhash = node.hex(successor)
                 commitmsg = commitmsg.replace(h, newhash[: len(h)])
             else:
                 repo.ui.note(
                     _(
                         b'The stale commit message reference to %s could '
                         b'not be updated\n(The referenced commit was dropped)\n'
                     )
                     % h
                 )
         else:
             repo.ui.note(
                 _(
                     b'The stale commit message reference to %s could '
                     b'not be updated\n'
                 )
                 % h
             )
 
     return commitmsg

tests/test-amend.t

@@ -1,531 +1,531 b''
 #testcases obsstore-off obsstore-on
 
   $ cat << EOF >> $HGRCPATH
   > [extensions]
   > amend=
   > debugdrawdag=$TESTDIR/drawdag.py
   > [diff]
   > git=1
   > EOF
 
 #if obsstore-on
   $ cat << EOF >> $HGRCPATH
   > [experimental]
   > evolution.createmarkers=True
   > EOF
 #endif
 
 Basic amend
 
   $ hg init repo1
   $ cd repo1
   $ hg debugdrawdag <<'EOS'
   > B
   > |
   > A
   > EOS
 
   $ hg update B -q
   $ echo 2 >> B
 
   $ hg amend
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/112478962961-7e959a55-amend.hg (obsstore-off !)
 #if obsstore-off
   $ hg log -p -G --hidden -T '{rev} {node|short} {desc}\n'
   @  1 be169c7e8dbe B
   |  diff --git a/B b/B
   |  new file mode 100644
   |  --- /dev/null
   |  +++ b/B
   |  @@ -0,0 +1,1 @@
   |  +B2
   |
   o  0 426bada5c675 A
      diff --git a/A b/A
      new file mode 100644
      --- /dev/null
      +++ b/A
      @@ -0,0 +1,1 @@
      +A
      \ No newline at end of file
   
 #else
   $ hg log -p -G --hidden -T '{rev} {node|short} {desc}\n'
   @  2 be169c7e8dbe B
   |  diff --git a/B b/B
   |  new file mode 100644
   |  --- /dev/null
   |  +++ b/B
   |  @@ -0,0 +1,1 @@
   |  +B2
   |
   | x  1 112478962961 B
   |/   diff --git a/B b/B
   |    new file mode 100644
   |    --- /dev/null
   |    +++ b/B
   |    @@ -0,0 +1,1 @@
   |    +B
   |    \ No newline at end of file
   |
   o  0 426bada5c675 A
      diff --git a/A b/A
      new file mode 100644
      --- /dev/null
      +++ b/A
      @@ -0,0 +1,1 @@
      +A
      \ No newline at end of file
   
 #endif
 
 Nothing changed
 
   $ hg amend
   nothing changed
   [1]
 
   $ hg amend -d "0 0"
   nothing changed
   [1]
 
   $ hg amend -d "Thu Jan 01 00:00:00 1970 UTC"
   nothing changed
   [1]
 
 #if obsstore-on
   $ hg init repo-merge-state
   $ cd repo-merge-state
   $ echo a > f
   $ hg ci -Aqm a
   $ echo b > f
   $ hg ci -Aqm b
   $ echo c > f
   $ hg co -m '.^'
   merging f
   warning: conflicts while merging f! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ echo d > f
   $ hg resolve -m f
   (no more unresolved files)
   $ hg ci --amend --config experimental.evolution.allowunstable=True
   1 new orphan changesets
   $ hg resolve -l
   $ cd ..
 #endif
 
 Matcher and metadata options
 
   $ echo 3 > C
   $ echo 4 > D
   $ hg add C D
   $ hg amend -m NEWMESSAGE -I C
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/be169c7e8dbe-7684ddc5-amend.hg (obsstore-off !)
   $ hg log -r . -T '{node|short} {desc} {files}\n'
   c7ba14d9075b NEWMESSAGE B C
   $ echo 5 > E
   $ rm C
   $ hg amend -d '2000 1000' -u 'Foo <[e-mail]>' -A C D
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/c7ba14d9075b-b3e76daa-amend.hg (obsstore-off !)
   $ hg log -r . -T '{node|short} {desc} {files} {author} {date}\n'
   14f6c4bcc865 NEWMESSAGE B D Foo <[e-mail]> 2000.01000
 
 Amend with editor
 
   $ cat > $TESTTMP/prefix.sh <<'EOF'
   > printf 'EDITED: ' > $TESTTMP/msg
   > cat "$1" >> $TESTTMP/msg
   > mv $TESTTMP/msg "$1"
   > EOF
   $ chmod +x $TESTTMP/prefix.sh
 
   $ HGEDITOR="sh $TESTTMP/prefix.sh" hg amend --edit
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/14f6c4bcc865-6591f15d-amend.hg (obsstore-off !)
   $ hg log -r . -T '{node|short} {desc}\n'
   298f085230c3 EDITED: NEWMESSAGE
   $ HGEDITOR="sh $TESTTMP/prefix.sh" hg amend -e -m MSG
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/298f085230c3-d81a6ad3-amend.hg (obsstore-off !)
   $ hg log -r . -T '{node|short} {desc}\n'
   974f07f28537 EDITED: MSG
 
   $ echo FOO > $TESTTMP/msg
   $ hg amend -l $TESTTMP/msg -m BAR
   abort: cannot specify both --message and --logfile
   [10]
   $ hg amend -l $TESTTMP/msg
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/974f07f28537-edb6470a-amend.hg (obsstore-off !)
   $ hg log -r . -T '{node|short} {desc}\n'
   507be9bdac71 FOO
 
 Interactive mode
 
   $ touch F G
   $ hg add F G
   $ cat <<EOS | hg amend -i --config ui.interactive=1
   > y
   > n
   > EOS
   diff --git a/F b/F
   new file mode 100644
   examine changes to 'F'?
   (enter ? for help) [Ynesfdaq?] y
   
   diff --git a/G b/G
   new file mode 100644
   examine changes to 'G'?
   (enter ? for help) [Ynesfdaq?] n
   
   saved backup bundle to $TESTTMP/repo1/.hg/strip-backup/507be9bdac71-c8077452-amend.hg (obsstore-off !)
   $ hg log -r . -T '{files}\n'
   B D F
 
 Amend in the middle of a stack
 
   $ hg init $TESTTMP/repo2
   $ cd $TESTTMP/repo2
   $ hg debugdrawdag <<'EOS'
   > C
   > |
   > B
   > |
   > A
   > EOS
 
   $ hg update -q B
   $ echo 2 >> B
   $ hg amend
   abort: cannot amend changeset with children
-  [255]
+  [10]
 
 #if obsstore-on
 
 With allowunstable, amend could work in the middle of a stack
 
   $ cat >> $HGRCPATH <<EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > EOF
 
   $ hg amend
   1 new orphan changesets
   $ hg log -T '{rev} {node|short} {desc}\n' -G
   @  3 be169c7e8dbe B
   |
   | *  2 26805aba1e60 C
   | |
   | x  1 112478962961 B
   |/
   o  0 426bada5c675 A
   
 Checking the note stored in the obsmarker
 
   $ echo foo > bar
   $ hg add bar
   $ hg amend --note 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'
   abort: cannot store a note of more than 255 bytes
   [10]
   $ hg amend --note "adding bar"
   $ hg debugobsolete -r .
   112478962961147124edd43549aedd1a335e44bf be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'operation': 'amend', 'user': 'test'}
   be169c7e8dbe21cd10b3d79691cbe7f241e3c21c 16084da537dd8f84cfdb3055c633772269d62e1b 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'note': 'adding bar', 'operation': 'amend', 'user': 'test'}
 #endif
 
 Cannot amend public changeset
 
   $ hg phase -r A --public
   $ hg update -C -q A
   $ hg amend -m AMEND
   abort: cannot amend public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
 
 Amend a merge changeset
 
   $ hg init $TESTTMP/repo3
   $ cd $TESTTMP/repo3
   $ hg debugdrawdag <<'EOS'
   >   C
   >  /|
   > A B
   > EOS
   $ hg update -q C
   $ hg amend -m FOO
   saved backup bundle to $TESTTMP/repo3/.hg/strip-backup/a35c07e8a2a4-15ff4612-amend.hg (obsstore-off !)
   $ rm .hg/localtags
   $ hg log -G -T '{desc}\n'
   @    FOO
   |\
   | o  B
   |
   o  A
   
 
 More complete test for status changes (issue5732)
 -------------------------------------------------
 
 Generates history of files having 3 states, r0_r1_wc:
 
  r0: ground (content/missing)
  r1: old state to be amended (content/missing, where missing means removed)
  wc: changes to be included in r1 (content/missing-tracked/untracked)
 
   $ hg init $TESTTMP/wcstates
   $ cd $TESTTMP/wcstates
 
   $ "$PYTHON" $TESTDIR/generate-working-copy-states.py state 2 1
   $ hg addremove -q --similarity 0
   $ hg commit -m0
 
   $ "$PYTHON" $TESTDIR/generate-working-copy-states.py state 2 2
   $ hg addremove -q --similarity 0
   $ hg commit -m1
 
   $ "$PYTHON" $TESTDIR/generate-working-copy-states.py state 2 wc
   $ hg addremove -q --similarity 0
   $ hg forget *_*_*-untracked
   $ rm *_*_missing-*
 
 amend r1 to include wc changes
 
   $ hg amend
   saved backup bundle to * (glob) (obsstore-off !)
 
 clean/modified/removed/added states of the amended revision
 
   $ hg status --all --change . 'glob:content1_*_content1-tracked'
   C content1_content1_content1-tracked
   C content1_content2_content1-tracked
   C content1_missing_content1-tracked
   $ hg status --all --change . 'glob:content1_*_content[23]-tracked'
   M content1_content1_content3-tracked
   M content1_content2_content2-tracked
   M content1_content2_content3-tracked
   M content1_missing_content3-tracked
   $ hg status --all --change . 'glob:content1_*_missing-tracked'
   M content1_content2_missing-tracked
   R content1_missing_missing-tracked
   C content1_content1_missing-tracked
   $ hg status --all --change . 'glob:content1_*_*-untracked'
   R content1_content1_content1-untracked
   R content1_content1_content3-untracked
   R content1_content1_missing-untracked
   R content1_content2_content1-untracked
   R content1_content2_content2-untracked
   R content1_content2_content3-untracked
   R content1_content2_missing-untracked
   R content1_missing_content1-untracked
   R content1_missing_content3-untracked
   R content1_missing_missing-untracked
   $ hg status --all --change . 'glob:missing_content2_*'
   A missing_content2_content2-tracked
   A missing_content2_content3-tracked
   A missing_content2_missing-tracked
   $ hg status --all --change . 'glob:missing_missing_*'
   A missing_missing_content3-tracked
 
 working directory should be all clean (with some missing/untracked files)
 
   $ hg status --all 'glob:*_content?-tracked'
   C content1_content1_content1-tracked
   C content1_content1_content3-tracked
   C content1_content2_content1-tracked
   C content1_content2_content2-tracked
   C content1_content2_content3-tracked
   C content1_missing_content1-tracked
   C content1_missing_content3-tracked
   C missing_content2_content2-tracked
   C missing_content2_content3-tracked
   C missing_missing_content3-tracked
   $ hg status --all 'glob:*_missing-tracked'
   ! content1_content1_missing-tracked
   ! content1_content2_missing-tracked
   ! content1_missing_missing-tracked
   ! missing_content2_missing-tracked
   ! missing_missing_missing-tracked
   $ hg status --all 'glob:*-untracked'
   ? content1_content1_content1-untracked
   ? content1_content1_content3-untracked
   ? content1_content2_content1-untracked
   ? content1_content2_content2-untracked
   ? content1_content2_content3-untracked
   ? content1_missing_content1-untracked
   ? content1_missing_content3-untracked
   ? missing_content2_content2-untracked
   ? missing_content2_content3-untracked
   ? missing_missing_content3-untracked
 
 =================================
 Test backup-bundle config option|
 =================================
   $ hg init $TESTTMP/repo4
   $ cd $TESTTMP/repo4
   $ echo a>a
   $ hg ci -Aqma
   $ echo oops>b
   $ hg ci -Aqm "b"
   $ echo partiallyfixed > b
 
 #if obsstore-off
   $ hg amend
   saved backup bundle to $TESTTMP/repo4/.hg/strip-backup/95e899acf2ce-f11cb050-amend.hg
 When backup-bundle config option is set:
   $ cat << EOF >> $HGRCPATH
   > [rewrite]
   > backup-bundle = False
   > EOF
   $ echo fixed > b
   $ hg amend
 
 #else
   $ hg amend
 When backup-bundle config option is set:
   $ cat << EOF >> $HGRCPATH
   > [rewrite]
   > backup-bundle = False
   > EOF
   $ echo fixed > b
   $ hg amend
 
 #endif
 ==========================================
 Test update-timestamp config option|
 ==========================================
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > amend=
   > mockmakedate = $TESTDIR/mockmakedate.py
   > EOF
 
   $ hg init $TESTTMP/repo5
   $ cd $TESTTMP/repo5
   $ cat <<'EOF' >> .hg/hgrc
   > [command-templates]
   > log = 'user:        {user}
   >        date:        {date|date}
   >        summary:     {desc|firstline}\n'
   > EOF
 
   $ echo a>a
   $ hg ci -Am 'commit 1'
   adding a
 
 When updatetimestamp is False
 
   $ hg amend --date '1997-1-1 0:1'
   $ hg log --limit 1
   user:        test
   date:        Wed Jan 01 00:01:00 1997 +0000
   summary:     commit 1
 
  When update-timestamp is True and no other change than the date
 
   $ hg amend --config rewrite.update-timestamp=True
   nothing changed
   [1]
   $ hg log --limit 1
   user:        test
   date:        Wed Jan 01 00:01:00 1997 +0000
   summary:     commit 1
 
 When update-timestamp is True and there is other change than the date
   $ hg amend --user foobar --config rewrite.update-timestamp=True
   $ hg log --limit 1
   user:        foobar
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     commit 1
 
 When date option is applicable and update-timestamp is True
   $ hg amend  --date '1998-1-1 0:1' --config rewrite.update-timestamp=True
   $ hg log --limit 1
   user:        foobar
   date:        Thu Jan 01 00:01:00 1998 +0000
   summary:     commit 1
 
 Unlike rewrite.update-timestamp, -D/--currentdate always updates the timestamp
 
   $ hg amend -D
   $ hg log --limit 1
   user:        foobar
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     commit 1
 
   $ hg amend -D --config rewrite.update-timestamp=True
   $ hg log --limit 1
   user:        foobar
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     commit 1
 
 rewrite.update-timestamp can be negated by --no-currentdate
 
   $ hg amend --config rewrite.update-timestamp=True --no-currentdate -u baz
   $ hg log --limit 1
   user:        baz
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     commit 1
 
 Bad combination of date options:
 
   $ hg amend -D --date '0 0'
   abort: cannot specify both --date and --currentdate
   [10]
 
 Close branch
 
   $ hg amend --secret --close-branch
   $ hg log --limit 1 -T 'close={get(extras, "close")}\nphase={phase}\n'
   close=1
   phase=secret
 
   $ cd ..
 
 Corner case of amend from issue6157:
 - working copy parent has a change to file `a`
 - working copy has the inverse change
 - we amend the working copy parent for files other than `a`
 hg used to include the changes to `a` anyway.
 
   $ hg init 6157; cd 6157
   $ echo a > a; echo b > b; hg commit -qAm_
   $ echo a2 > a; hg commit -qm_
   $ hg diff --stat -c .
    a |  2 +-
    1 files changed, 1 insertions(+), 1 deletions(-)
   $ echo a > a; echo b2 > b; hg amend -q b
   $ hg diff --stat -c .
    a |  2 +-
    b |  2 +-
    2 files changed, 2 insertions(+), 2 deletions(-)
 
 Modifying a file while the editor is open can cause dirstate corruption
 (issue6233)
 
   $ cd $TESTTMP
   $ hg init modify-during-amend; cd modify-during-amend
   $ echo r0 > foo; hg commit -qAm "r0"
   $ echo alpha > foo; hg commit -qm "alpha"
   $ echo beta >> foo
   $ cat > $TESTTMP/touchy_editor.sh <<EOF
   > sleep 1
   > echo delta >> "$TESTTMP/modify-during-amend/foo"
   > sleep 1
   > echo hi > "\$1"
   > sleep 1
   > EOF
   $ HGEDITOR="sh $TESTTMP/touchy_editor.sh" hg commit --amend
   $ if (hg diff -c . | grep 'delta' >/dev/null) || [ -n "$(hg status)" ]; then
   >   echo "OK."
   > else
   >   echo "Bug detected. 'delta' is not part of the commit OR the wdir"
   >   echo "Diff and status before rebuild:"
   >   hg diff
   >   hg status
   >   hg debugrebuilddirstate
   >   echo "Diff and status after rebuild:"
   >   hg diff
   >   hg status
   > fi
   OK.

tests/test-branch-change.t

@@ -1,430 +1,430 b''
 Testing changing branch on commits
 ==================================
 
 Setup
 
   $ cat >> $HGRCPATH << EOF
   > [alias]
   > glog = log -G -T "{rev}:{node|short} {desc}\n{branch} ({bookmarks})"
   > [experimental]
   > evolution = createmarkers
   > [extensions]
   > rebase=
   > EOF
 
   $ hg init repo
   $ cd repo
   $ for ch in a b c d e; do echo foo >> $ch; hg ci -Aqm "Added "$ch; done
   $ hg glog
   @  4:aa98ab95a928 Added e
   |  default ()
   o  3:62615734edd5 Added d
   |  default ()
   o  2:28ad74487de9 Added c
   |  default ()
   o  1:29becc82797a Added b
   |  default ()
   o  0:18d04c59bb5d Added a
      default ()
 
   $ hg branches
   default                        4:aa98ab95a928
 
 Try without passing a new branch name
 
   $ hg branch -r .
   abort: no branch name specified for the revisions
   [10]
 
 Setting an invalid branch name
 
   $ hg branch -r . a:b
   abort: ':' cannot be used in a name
   [10]
   $ hg branch -r . tip
   abort: the name 'tip' is reserved
   [10]
   $ hg branch -r . 1234
   abort: cannot use an integer as a name
   [10]
 
 Change on non-linear set of commits
 
   $ hg branch -r 2 -r 4 foo
   abort: cannot change branch of non-linear revisions
   [10]
 
 Change in middle of the stack (linear commits)
 
   $ hg branch -r 1::3 foo
   abort: cannot change branch of changeset with children
-  [255]
+  [10]
 
 Change with dirty working directory
 
   $ echo bar > a
   $ hg branch -r . foo
   abort: uncommitted changes
   [20]
 
   $ hg revert --all
   reverting a
 
 Change on empty revision set
 
   $ hg branch -r 'draft() - all()' foo
   abort: empty revision set
   [10]
 
 Changing branch on linear set of commits from head
 
 Without obsmarkers
 
   $ hg branch -r 3:4 foo --config experimental.evolution=!
   changed branch on 2 changesets
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/62615734edd5-e86bd13a-branch-change.hg
   $ hg glog
   @  4:3938acfb5c0f Added e
   |  foo ()
   o  3:9435da006bdc Added d
   |  foo ()
   o  2:28ad74487de9 Added c
   |  default ()
   o  1:29becc82797a Added b
   |  default ()
   o  0:18d04c59bb5d Added a
      default ()
 
   $ hg branches
   foo                            4:3938acfb5c0f
   default                        2:28ad74487de9 (inactive)
 
 With obsmarkers
 
   $ hg branch -r 3::4 bar
   changed branch on 2 changesets
   $ hg glog
   @  6:7c1991464886 Added e
   |  bar ()
   o  5:1ea05e93925f Added d
   |  bar ()
   o  2:28ad74487de9 Added c
   |  default ()
   o  1:29becc82797a Added b
   |  default ()
   o  0:18d04c59bb5d Added a
      default ()
 
   $ hg branches
   bar                            6:7c1991464886
   default                        2:28ad74487de9 (inactive)
 
 Change branch name to an existing branch
 
   $ hg branch -r . default
   abort: a branch of the same name already exists
   [10]
 
 Changing on a branch head which is not topological head
 
   $ hg branch -r 2 stable
   abort: cannot change branch of changeset with children
-  [255]
+  [10]
 
 Enabling the allowunstable config and trying to change branch on a branch head
 which is not a topological head
 
   $ echo "[experimental]" >> .hg/hgrc
   $ echo "evolution.allowunstable=yes" >> .hg/hgrc
   $ hg branch -r 2 foo
   changed branch on 1 changesets
   2 new orphan changesets
 
 Changing branch of an obsoleted changeset
 
   $ hg branch -r 4 foobar
   abort: hidden revision '4' was rewritten as: 7c1991464886!
   (use --hidden to access hidden revisions)
   [255]
 
   $ hg branch -r 4 --hidden foobar
   abort: cannot change branch of a obsolete changeset
   [10]
 
 Make sure bookmark movement is correct
 
   $ hg bookmark b1
   $ hg glog -r '.^::'
   @  6:7c1991464886 Added e
   |  bar (b1)
   *  5:1ea05e93925f Added d
   |  bar ()
   ~
 
   $ hg branch -r '(.^)::' wat --debug
   changing branch of '1ea05e93925f806d875a2163f9b76764be644636' from 'bar' to 'wat'
   committing files:
   d
   committing manifest
   committing changelog
   new node id is 343660ccab7400da637bd6a211d07f413536d718
   changing branch of '7c19914648869f5b02fc7fed31ddee9783fdd680' from 'bar' to 'wat'
   committing files:
   e
   committing manifest
   committing changelog
   new node id is de1404b45a69f8cc6437d7679033ee33e9efb4ba
   moving bookmarks ['b1'] from 7c19914648869f5b02fc7fed31ddee9783fdd680 to de1404b45a69f8cc6437d7679033ee33e9efb4ba
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: 7c1991464886, local: 7c1991464886+, remote: de1404b45a69
   starting 4 threads for background file closing (?)
   changed branch on 2 changesets
   updating the branch cache
   invalid branch cache (served): tip differs
 
   $ hg glog -r '(.^)::'
   @  9:de1404b45a69 Added e
   |  wat (b1)
   *  8:343660ccab74 Added d
   |  wat ()
   ~
 
 Make sure phase handling is correct
 
   $ echo foo >> bar
   $ hg ci -Aqm "added bar" --secret
   1 new orphan changesets
   $ hg glog -r .
   @  10:8ad1294c1660 added bar
   |  wat (b1)
   ~
   $ hg branch -r . secret
   changed branch on 1 changesets
   $ hg phase -r .
   11: secret
 
   $ hg branches
   secret                        11:38a9b2d53f98
   foo                            7:8a4729a5e2b8
   wat                            9:de1404b45a69 (inactive)
   default                        2:28ad74487de9 (inactive)
   $ hg branch
   secret
 
 Changing branch of another head, different from one on which we are
 
   $ hg glog
   @  11:38a9b2d53f98 added bar
   |  secret (b1)
   *  9:de1404b45a69 Added e
   |  wat ()
   *  8:343660ccab74 Added d
   |  wat ()
   | o  7:8a4729a5e2b8 Added c
   | |  foo ()
   x |  2:28ad74487de9 Added c
   |/   default ()
   o  1:29becc82797a Added b
   |  default ()
   o  0:18d04c59bb5d Added a
      default ()
 
   $ hg branch
   secret
 
   $ hg branch -r 7 foobar
   changed branch on 1 changesets
 
 The current branch must be preserved
   $ hg branch
   secret
 
 Changing branch on multiple heads at once
 
   $ hg rebase -s 8 -d 12 --keepbranches -q
 
   $ hg rebase -s 14 -d 1 --keepbranches -q
 
   $ hg branch -r 0: stable
   changed branch on 6 changesets
   $ hg glog
   @  23:6a5ddbcfb870 added bar
   |  stable (b1)
   o  22:baedc6e98a67 Added e
   |  stable ()
   | o  21:99ac7bf8aad1 Added d
   | |  stable ()
   | o  20:0ecb4d39c4bd Added c
   |/   stable ()
   o  19:fd45b986b109 Added b
   |  stable ()
   o  18:204d2769eca2 Added a
      stable ()
 
   $ hg branches
   stable                        23:6a5ddbcfb870
 
   $ hg branch
   stable
 
 Changing to same branch is no-op
 
   $ hg branch -r 19::21 stable
   changed branch on 0 changesets
 
 Changing branch name to existing branch name if the branch of parent of root of
 revs is same as the new branch name
 
   $ hg branch -r 20::21 bugfix
   changed branch on 2 changesets
   $ hg glog
   o  25:714defe1cf34 Added d
   |  bugfix ()
   o  24:98394def28fc Added c
   |  bugfix ()
   | @  23:6a5ddbcfb870 added bar
   | |  stable (b1)
   | o  22:baedc6e98a67 Added e
   |/   stable ()
   o  19:fd45b986b109 Added b
   |  stable ()
   o  18:204d2769eca2 Added a
      stable ()
 
   $ hg branch -r 24:25 stable
   changed branch on 2 changesets
   $ hg glog
   o  27:4ec342341562 Added d
   |  stable ()
   o  26:83f48859c2de Added c
   |  stable ()
   | @  23:6a5ddbcfb870 added bar
   | |  stable (b1)
   | o  22:baedc6e98a67 Added e
   |/   stable ()
   o  19:fd45b986b109 Added b
   |  stable ()
   o  18:204d2769eca2 Added a
      stable ()
 
 Changing branch of a merge commit
 
   $ hg branch -q ghi
   $ echo f > f
   $ hg ci -qAm 'Added f'
   $ hg up -q 27
   $ hg branch -q jkl
   $ echo g > g
   $ hg ci -qAm 'Added g'
   $ hg glog -r 'heads(:)'
   @  29:6bc1c6c2c9da Added g
   |  jkl ()
   ~
   o  28:2f1019bd29d2 Added f
   |  ghi (b1)
   ~
 
   $ hg branch -q default
   $ hg merge -r 28
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg branch -r . abcd
   abort: outstanding uncommitted merge
   [20]
 
   $ hg ci -m "Merge commit"
   $ hg glog -r 'parents(.)::'
   @    30:4d56e6b1eb6b Merge commit
   |\   default ()
   | o  29:6bc1c6c2c9da Added g
   | |  jkl ()
   | ~
   o  28:2f1019bd29d2 Added f
   |  ghi (b1)
   ~
 
   $ hg branch -r . ghi
   0 files updated, 0 files merged, 4 files removed, 0 files unresolved
   changed branch on 1 changesets
   $ hg branch -r . jkl
   changed branch on 1 changesets
   $ hg branch -r . default
   changed branch on 1 changesets
   $ hg branch -r . stable
   abort: a branch of the same name already exists
   [10]
 
   $ hg branch -r . stable --force
   changed branch on 1 changesets
   $ hg branches
   stable                        34:d1c2addda4a2
   jkl                           29:6bc1c6c2c9da (inactive)
   ghi                           28:2f1019bd29d2 (inactive)
 
 Changing branch on public changeset
 
   $ hg phase -r . -p
   $ hg branch -r . def
   abort: cannot change branch of public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
 
 Merge commit with conflicts, with evolution and without
 
   $ mklozenge() {
   >   echo foo > a
   >   hg ci -qAm foo
   >   echo bar > a
   >   hg ci -qm bar
   >   hg up -q '.^'
   >   echo baz > a
   >   hg ci -qm baz
   >   hg merge -q -t :local
   >   echo neither > a
   >   hg ci -qm neither
   > }
 
   $ cd ..
   $ hg init merge-with-evolution
   $ cd merge-with-evolution
   $ mklozenge
 
   $ hg branch -r '(.^)::' abc
   changed branch on 2 changesets
   $ hg glog
   @    5:c07fa8b34d54 neither
   |\   abc ()
   | o  4:f2aa51777cc9 baz
   | |  abc ()
   o |  1:2e33c4f0856b bar
   |/   default ()
   o  0:91cfb6004abf foo
      default ()
   $ hg cat a
   neither
 
   $ cd ..
   $ hg init merge-without-evolution
   $ cd merge-without-evolution
   $ mklozenge
   $ cat > .hg/hgrc << EOF
   > [experimental]
   > evolution = no
   > evolution.allowunstable = no
   > EOF
 
   $ hg branch -r '(.^)::' abc
   changed branch on 2 changesets
   saved backup bundle to $TESTTMP/merge-without-evolution/.hg/strip-backup/9a3a2af368f4-8db1a361-branch-change.hg
   $ hg glog
   @    3:c07fa8b34d54 neither
   |\   abc ()
   | o  2:f2aa51777cc9 baz
   | |  abc ()
   o |  1:2e33c4f0856b bar
   |/   default ()
   o  0:91cfb6004abf foo
      default ()
   $ hg cat a
   neither

tests/test-commit-amend.t

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

tests/test-fix.t

@@ -1,1693 +1,1693 b''
 A script that implements uppercasing of specific lines in a file. This
 approximates the behavior of code formatters well enough for our tests.
 
   $ UPPERCASEPY="$TESTTMP/uppercase.py"
   $ cat > $UPPERCASEPY <<EOF
   > import sys
   > from mercurial.utils.procutil import setbinary
   > setbinary(sys.stdin)
   > setbinary(sys.stdout)
   > lines = set()
   > for arg in sys.argv[1:]:
   >   if arg == 'all':
   >     sys.stdout.write(sys.stdin.read().upper())
   >     sys.exit(0)
   >   else:
   >     first, last = arg.split('-')
   >     lines.update(range(int(first), int(last) + 1))
   > for i, line in enumerate(sys.stdin.readlines()):
   >   if i + 1 in lines:
   >     sys.stdout.write(line.upper())
   >   else:
   >     sys.stdout.write(line)
   > EOF
   $ TESTLINES="foo\nbar\nbaz\nqux\n"
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY
   foo
   bar
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY all
   FOO
   BAR
   BAZ
   QUX
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 1-1
   FOO
   bar
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 1-2
   FOO
   BAR
   baz
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 2-3
   foo
   BAR
   BAZ
   qux
   $ printf $TESTLINES | "$PYTHON" $UPPERCASEPY 2-2 4-4
   foo
   BAR
   baz
   QUX
 
 Set up the config with two simple fixers: one that fixes specific line ranges,
 and one that always fixes the whole file. They both "fix" files by converting
 letters to uppercase. They use different file extensions, so each test case can
 choose which behavior to use by naming files.
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > fix =
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > [fix]
   > uppercase-whole-file:command="$PYTHON" $UPPERCASEPY all
   > uppercase-whole-file:pattern=set:**.whole
   > uppercase-changed-lines:command="$PYTHON" $UPPERCASEPY
   > uppercase-changed-lines:linerange={first}-{last}
   > uppercase-changed-lines:pattern=set:**.changed
   > EOF
 
 Help text for fix.
 
   $ hg help fix
   hg fix [OPTION]... [FILE]...
   
   rewrite file content in changesets or working directory
   
       Runs any configured tools to fix the content of files. Only affects files
       with changes, unless file arguments are provided. Only affects changed
       lines of files, unless the --whole flag is used. Some tools may always
       affect the whole file regardless of --whole.
   
       If --working-dir is used, files with uncommitted changes in the working
       copy will be fixed. Note that no backup are made.
   
       If revisions are specified with --source, those revisions and their
       descendants will be checked, and they may be replaced with new revisions
       that have fixed file content. By automatically including the descendants,
       no merging, rebasing, or evolution will be required. If an ancestor of the
       working copy is included, then the working copy itself will also be fixed,
       and the working copy will be updated to the fixed parent.
   
       When determining what lines of each file to fix at each revision, the
       whole set of revisions being fixed is considered, so that fixes to earlier
       revisions are not forgotten in later ones. The --base flag can be used to
       override this default behavior, though it is not usually desirable to do
       so.
   
   (use 'hg help -e fix' to show help for the fix extension)
   
   options ([+] can be repeated):
   
       --all            fix all non-public non-obsolete revisions
       --base REV [+]   revisions to diff against (overrides automatic selection,
                        and applies to every revision being fixed)
    -s --source REV [+] fix the specified revisions and their descendants
    -w --working-dir    fix the working directory
       --whole          always fix every line of a file
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg help -e fix
   fix extension - rewrite file content in changesets or working copy
   (EXPERIMENTAL)
   
   Provides a command that runs configured tools on the contents of modified
   files, writing back any fixes to the working copy or replacing changesets.
   
   Here is an example configuration that causes 'hg fix' to apply automatic
   formatting fixes to modified lines in C++ code:
   
     [fix]
     clang-format:command=clang-format --assume-filename={rootpath}
     clang-format:linerange=--lines={first}:{last}
     clang-format:pattern=set:**.cpp or **.hpp
   
   The :command suboption forms the first part of the shell command that will be
   used to fix a file. The content of the file is passed on standard input, and
   the fixed file content is expected on standard output. Any output on standard
   error will be displayed as a warning. If the exit status is not zero, the file
   will not be affected. A placeholder warning is displayed if there is a non-
   zero exit status but no standard error output. Some values may be substituted
   into the command:
   
     {rootpath}  The path of the file being fixed, relative to the repo root
     {basename}  The name of the file being fixed, without the directory path
   
   If the :linerange suboption is set, the tool will only be run if there are
   changed lines in a file. The value of this suboption is appended to the shell
   command once for every range of changed lines in the file. Some values may be
   substituted into the command:
   
     {first}   The 1-based line number of the first line in the modified range
     {last}    The 1-based line number of the last line in the modified range
   
   Deleted sections of a file will be ignored by :linerange, because there is no
   corresponding line range in the version being fixed.
   
   By default, tools that set :linerange will only be executed if there is at
   least one changed line range. This is meant to prevent accidents like running
   a code formatter in such a way that it unexpectedly reformats the whole file.
   If such a tool needs to operate on unchanged files, it should set the
   :skipclean suboption to false.
   
   The :pattern suboption determines which files will be passed through each
   configured tool. See 'hg help patterns' for possible values. However, all
   patterns are relative to the repo root, even if that text says they are
   relative to the current working directory. If there are file arguments to 'hg
   fix', the intersection of these patterns is used.
   
   There is also a configurable limit for the maximum size of file that will be
   processed by 'hg fix':
   
     [fix]
     maxfilesize = 2MB
   
   Normally, execution of configured tools will continue after a failure
   (indicated by a non-zero exit status). It can also be configured to abort
   after the first such failure, so that no files will be affected if any tool
   fails. This abort will also cause 'hg fix' to exit with a non-zero status:
   
     [fix]
     failure = abort
   
   When multiple tools are configured to affect a file, they execute in an order
   defined by the :priority suboption. The priority suboption has a default value
   of zero for each tool. Tools are executed in order of descending priority. The
   execution order of tools with equal priority is unspecified. For example, you
   could use the 'sort' and 'head' utilities to keep only the 10 smallest numbers
   in a text file by ensuring that 'sort' runs before 'head':
   
     [fix]
     sort:command = sort -n
     head:command = head -n 10
     sort:pattern = numbers.txt
     head:pattern = numbers.txt
     sort:priority = 2
     head:priority = 1
   
   To account for changes made by each tool, the line numbers used for
   incremental formatting are recomputed before executing the next tool. So, each
   tool may see different values for the arguments added by the :linerange
   suboption.
   
   Each fixer tool is allowed to return some metadata in addition to the fixed
   file content. The metadata must be placed before the file content on stdout,
   separated from the file content by a zero byte. The metadata is parsed as a
   JSON value (so, it should be UTF-8 encoded and contain no zero bytes). A fixer
   tool is expected to produce this metadata encoding if and only if the
   :metadata suboption is true:
   
     [fix]
     tool:command = tool --prepend-json-metadata
     tool:metadata = true
   
   The metadata values are passed to hooks, which can be used to print summaries
   or perform other post-fixing work. The supported hooks are:
   
     "postfixfile"
       Run once for each file in each revision where any fixer tools made changes
       to the file content. Provides "$HG_REV" and "$HG_PATH" to identify the file,
       and "$HG_METADATA" with a map of fixer names to metadata values from fixer
       tools that affected the file. Fixer tools that didn't affect the file have a
       value of None. Only fixer tools that executed are present in the metadata.
   
     "postfix"
       Run once after all files and revisions have been handled. Provides
       "$HG_REPLACEMENTS" with information about what revisions were created and
       made obsolete. Provides a boolean "$HG_WDIRWRITTEN" to indicate whether any
       files in the working copy were updated. Provides a list "$HG_METADATA"
       mapping fixer tool names to lists of metadata values returned from
       executions that modified a file. This aggregates the same metadata
       previously passed to the "postfixfile" hook.
   
   Fixer tools are run in the repository's root directory. This allows them to
   read configuration files from the working copy, or even write to the working
   copy. The working copy is not updated to match the revision being fixed. In
   fact, several revisions may be fixed in parallel. Writes to the working copy
   are not amended into the revision being fixed; fixer tools should always write
   fixed file content back to stdout as documented above.
   
   list of commands:
   
    fix           rewrite file content in changesets or working directory
   
   (use 'hg help -v -e fix' to show built-in aliases and global options)
 
 There is no default behavior in the absence of --rev and --working-dir.
 
   $ hg init badusage
   $ cd badusage
 
   $ hg fix
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
   $ hg fix --whole
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
   $ hg fix --base 0
   abort: no changesets specified
   (use --source or --working-dir)
   [255]
 
 Fixing a public revision isn't allowed. It should abort early enough that
 nothing happens, even to the working directory.
 
   $ printf "hello\n" > hello.whole
   $ hg commit -Aqm "hello"
   $ hg phase -r 0 --public
   $ hg fix -r 0
   abort: cannot fix public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
   $ hg fix -r 0 --working-dir
   abort: cannot fix public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
   $ hg cat -r tip hello.whole
   hello
   $ cat hello.whole
   hello
 
   $ cd ..
 
 Fixing a clean working directory should do nothing. Even the --whole flag
 shouldn't cause any clean files to be fixed. Specifying a clean file explicitly
 should only fix it if the fixer always fixes the whole file. The combination of
 an explicit filename and --whole should format the entire file regardless.
 
   $ hg init fixcleanwdir
   $ cd fixcleanwdir
 
   $ printf "hello\n" > hello.changed
   $ printf "world\n" > hello.whole
   $ hg commit -Aqm "foo"
   $ hg fix --working-dir
   $ hg diff
   $ hg fix --working-dir --whole
   $ hg diff
   $ hg fix --working-dir *
   $ cat *
   hello
   WORLD
   $ hg revert --all --no-backup
   reverting hello.whole
   $ hg fix --working-dir * --whole
   $ cat *
   HELLO
   WORLD
 
 The same ideas apply to fixing a revision, so we create a revision that doesn't
 modify either of the files in question and try fixing it. This also tests that
 we ignore a file that doesn't match any configured fixer.
 
   $ hg revert --all --no-backup
   reverting hello.changed
   reverting hello.whole
   $ printf "unimportant\n" > some.file
   $ hg commit -Aqm "some other file"
 
   $ hg fix -r .
   $ hg cat -r tip *
   hello
   world
   unimportant
   $ hg fix -r . --whole
   $ hg cat -r tip *
   hello
   world
   unimportant
   $ hg fix -r . *
   $ hg cat -r tip *
   hello
   WORLD
   unimportant
   $ hg fix -r . * --whole --config experimental.evolution.allowdivergence=true
   2 new content-divergent changesets
   $ hg cat -r tip *
   HELLO
   WORLD
   unimportant
 
   $ cd ..
 
 Fixing the working directory should still work if there are no revisions.
 
   $ hg init norevisions
   $ cd norevisions
 
   $ printf "something\n" > something.whole
   $ hg add
   adding something.whole
   $ hg fix --working-dir
   $ cat something.whole
   SOMETHING
 
   $ cd ..
 
 Test the effect of fixing the working directory for each possible status, with
 and without providing explicit file arguments.
 
   $ hg init implicitlyfixstatus
   $ cd implicitlyfixstatus
 
   $ printf "modified\n" > modified.whole
   $ printf "removed\n" > removed.whole
   $ printf "deleted\n" > deleted.whole
   $ printf "clean\n" > clean.whole
   $ printf "ignored.whole" > .hgignore
   $ hg commit -Aqm "stuff"
 
   $ printf "modified!!!\n" > modified.whole
   $ printf "unknown\n" > unknown.whole
   $ printf "ignored\n" > ignored.whole
   $ printf "added\n" > added.whole
   $ hg add added.whole
   $ hg remove removed.whole
   $ rm deleted.whole
 
   $ hg status --all
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
   C clean.whole
 
   $ hg fix --working-dir
 
   $ hg status --all
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
   C clean.whole
 
   $ cat *.whole
   ADDED
   clean
   ignored
   MODIFIED!!!
   unknown
 
   $ printf "modified!!!\n" > modified.whole
   $ printf "added\n" > added.whole
 
 Listing the files explicitly causes untracked files to also be fixed, but
 ignored files are still unaffected.
 
   $ hg fix --working-dir *.whole
 
   $ hg status --all
   M clean.whole
   M modified.whole
   A added.whole
   R removed.whole
   ! deleted.whole
   ? unknown.whole
   I ignored.whole
   C .hgignore
 
   $ cat *.whole
   ADDED
   CLEAN
   ignored
   MODIFIED!!!
   UNKNOWN
 
   $ cd ..
 
 Test that incremental fixing works on files with additions, deletions, and
 changes in multiple line ranges. Note that deletions do not generally cause
 neighboring lines to be fixed, so we don't return a line range for purely
 deleted sections. In the future we should support a :deletion config that
 allows fixers to know where deletions are located.
 
   $ hg init incrementalfixedlines
   $ cd incrementalfixedlines
 
   $ printf "a\nb\nc\nd\ne\nf\ng\n" > foo.txt
   $ hg commit -Aqm "foo"
   $ printf "zz\na\nc\ndd\nee\nff\nf\ngg\n" > foo.txt
 
   $ hg --config "fix.fail:command=echo" \
   >    --config "fix.fail:linerange={first}:{last}" \
   >    --config "fix.fail:pattern=foo.txt" \
   >    fix --working-dir
   $ cat foo.txt
   1:1 4:6 8:8
 
   $ cd ..
 
 Test that --whole fixes all lines regardless of the diffs present.
 
   $ hg init wholeignoresdiffs
   $ cd wholeignoresdiffs
 
   $ printf "a\nb\nc\nd\ne\nf\ng\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ printf "zz\na\nc\ndd\nee\nff\nf\ngg\n" > foo.changed
 
   $ hg fix --working-dir
   $ cat foo.changed
   ZZ
   a
   c
   DD
   EE
   FF
   f
   GG
 
   $ hg fix --working-dir --whole
   $ cat foo.changed
   ZZ
   A
   C
   DD
   EE
   FF
   F
   GG
 
   $ cd ..
 
 We should do nothing with symlinks, and their targets should be unaffected. Any
 other behavior would be more complicated to implement and harder to document.
 
 #if symlink
   $ hg init dontmesswithsymlinks
   $ cd dontmesswithsymlinks
 
   $ printf "hello\n" > hello.whole
   $ ln -s hello.whole hellolink
   $ hg add
   adding hello.whole
   adding hellolink
   $ hg fix --working-dir hellolink
   $ hg status
   A hello.whole
   A hellolink
 
   $ cd ..
 #endif
 
 We should allow fixers to run on binary files, even though this doesn't sound
 like a common use case. There's not much benefit to disallowing it, and users
 can add "and not binary()" to their filesets if needed. The Mercurial
 philosophy is generally to not handle binary files specially anyway.
 
   $ hg init cantouchbinaryfiles
   $ cd cantouchbinaryfiles
 
   $ printf "hello\0\n" > hello.whole
   $ hg add
   adding hello.whole
   $ hg fix --working-dir 'set:binary()'
   $ cat hello.whole
   HELLO\x00 (esc)
 
   $ cd ..
 
 We have a config for the maximum size of file we will attempt to fix. This can
 be helpful to avoid running unsuspecting fixer tools on huge inputs, which
 could happen by accident without a well considered configuration. A more
 precise configuration could use the size() fileset function if one global limit
 is undesired.
 
   $ hg init maxfilesize
   $ cd maxfilesize
 
   $ printf "this file is huge\n" > hello.whole
   $ hg add
   adding hello.whole
   $ hg --config fix.maxfilesize=10 fix --working-dir
   ignoring file larger than 10 bytes: hello.whole
   $ cat hello.whole
   this file is huge
 
   $ cd ..
 
 If we specify a file to fix, other files should be left alone, even if they
 have changes.
 
   $ hg init fixonlywhatitellyouto
   $ cd fixonlywhatitellyouto
 
   $ printf "fix me!\n" > fixme.whole
   $ printf "not me.\n" > notme.whole
   $ hg add
   adding fixme.whole
   adding notme.whole
   $ hg fix --working-dir fixme.whole
   $ cat *.whole
   FIX ME!
   not me.
 
   $ cd ..
 
 If we try to fix a missing file, we still fix other files.
 
   $ hg init fixmissingfile
   $ cd fixmissingfile
 
   $ printf "fix me!\n" > foo.whole
   $ hg add
   adding foo.whole
   $ hg fix --working-dir foo.whole bar.whole
   bar.whole: $ENOENT$
   $ cat *.whole
   FIX ME!
 
   $ cd ..
 
 Specifying a directory name should fix all its files and subdirectories.
 
   $ hg init fixdirectory
   $ cd fixdirectory
 
   $ mkdir -p dir1/dir2
   $ printf "foo\n" > foo.whole
   $ printf "bar\n" > dir1/bar.whole
   $ printf "baz\n" > dir1/dir2/baz.whole
   $ hg add
   adding dir1/bar.whole
   adding dir1/dir2/baz.whole
   adding foo.whole
   $ hg fix --working-dir dir1
   $ cat foo.whole dir1/bar.whole dir1/dir2/baz.whole
   foo
   BAR
   BAZ
 
   $ cd ..
 
 Fixing a file in the working directory that needs no fixes should not actually
 write back to the file, so for example the mtime shouldn't change.
 
   $ hg init donttouchunfixedfiles
   $ cd donttouchunfixedfiles
 
   $ printf "NO FIX NEEDED\n" > foo.whole
   $ hg add
   adding foo.whole
   $ cp -p foo.whole foo.whole.orig
   $ cp -p foo.whole.orig foo.whole
   $ sleep 2 # mtime has a resolution of one or two seconds.
   $ hg fix --working-dir
   $ f foo.whole.orig --newer foo.whole
   foo.whole.orig: newer than foo.whole
 
   $ cd ..
 
 When a fixer prints to stderr, we don't assume that it has failed. We show the
 error messages to the user, and we still let the fixer affect the file it was
 fixing if its exit code is zero. Some code formatters might emit error messages
 on stderr and nothing on stdout, which would cause us the clear the file,
 except that they also exit with a non-zero code. We show the user which fixer
 emitted the stderr, and which revision, but we assume that the fixer will print
 the filename if it is relevant (since the issue may be non-specific). There is
 also a config to abort (without affecting any files whatsoever) if we see any
 tool with a non-zero exit status.
 
   $ hg init showstderr
   $ cd showstderr
 
   $ printf "hello\n" > hello.txt
   $ hg add
   adding hello.txt
   $ cat > $TESTTMP/work.sh <<'EOF'
   > printf 'HELLO\n'
   > printf "$@: some\nerror that didn't stop the tool" >&2
   > exit 0 # success despite the stderr output
   > EOF
   $ hg --config "fix.work:command=sh $TESTTMP/work.sh {rootpath}" \
   >    --config "fix.work:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] work: hello.txt: some
   [wdir] work: error that didn't stop the tool
   $ cat hello.txt
   HELLO
 
   $ printf "goodbye\n" > hello.txt
   $ printf "foo\n" > foo.whole
   $ hg add
   adding foo.whole
   $ cat > $TESTTMP/fail.sh <<'EOF'
   > printf 'GOODBYE\n'
   > printf "$@: some\nerror that did stop the tool\n" >&2
   > exit 42 # success despite the stdout output
   > EOF
   $ hg --config "fix.fail:command=sh $TESTTMP/fail.sh {rootpath}" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    --config "fix.failure=abort" \
   >    fix --working-dir
   [wdir] fail: hello.txt: some
   [wdir] fail: error that did stop the tool
   abort: no fixes will be applied
   (use --config fix.failure=continue to apply any successful fixes anyway)
   [255]
   $ cat hello.txt
   goodbye
   $ cat foo.whole
   foo
 
   $ hg --config "fix.fail:command=sh $TESTTMP/fail.sh {rootpath}" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] fail: hello.txt: some
   [wdir] fail: error that did stop the tool
   $ cat hello.txt
   goodbye
   $ cat foo.whole
   FOO
 
   $ hg --config "fix.fail:command=exit 42" \
   >    --config "fix.fail:pattern=hello.txt" \
   >    fix --working-dir
   [wdir] fail: exited with status 42
 
   $ cd ..
 
 Fixing the working directory and its parent revision at the same time should
 check out the replacement revision for the parent. This prevents any new
 uncommitted changes from appearing. We test this for a clean working directory
 and a dirty one. In both cases, all lines/files changed since the grandparent
 will be fixed. The grandparent is the "baserev" for both the parent and the
 working copy.
 
   $ hg init fixdotandcleanwdir
   $ cd fixdotandcleanwdir
 
   $ printf "hello\n" > hello.whole
   $ printf "world\n" > world.whole
   $ hg commit -Aqm "the parent commit"
 
   $ hg parents --template '{rev} {desc}\n'
   0 the parent commit
   $ hg fix --working-dir -r .
   $ hg parents --template '{rev} {desc}\n'
   1 the parent commit
   $ hg cat -r . *.whole
   HELLO
   WORLD
   $ cat *.whole
   HELLO
   WORLD
   $ hg status
 
   $ cd ..
 
 Same test with a dirty working copy.
 
   $ hg init fixdotanddirtywdir
   $ cd fixdotanddirtywdir
 
   $ printf "hello\n" > hello.whole
   $ printf "world\n" > world.whole
   $ hg commit -Aqm "the parent commit"
 
   $ printf "hello,\n" > hello.whole
   $ printf "world!\n" > world.whole
 
   $ hg parents --template '{rev} {desc}\n'
   0 the parent commit
   $ hg fix --working-dir -r .
   $ hg parents --template '{rev} {desc}\n'
   1 the parent commit
   $ hg cat -r . *.whole
   HELLO
   WORLD
   $ cat *.whole
   HELLO,
   WORLD!
   $ hg status
   M hello.whole
   M world.whole
 
   $ cd ..
 
 When we have a chain of commits that change mutually exclusive lines of code,
 we should be able to do incremental fixing that causes each commit in the chain
 to include fixes made to the previous commits. This prevents children from
 backing out the fixes made in their parents. A dirty working directory is
 conceptually similar to another commit in the chain.
 
   $ hg init incrementallyfixchain
   $ cd incrementallyfixchain
 
   $ cat > file.changed <<EOF
   > first
   > second
   > third
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the common ancestor (the baserev)"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the first commit to fix"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third (changed)
   > fourth
   > fifth
   > EOF
   $ hg commit -Aqm "the second commit to fix"
   $ cat > file.changed <<EOF
   > first (changed)
   > second
   > third (changed)
   > fourth
   > fifth (changed)
   > EOF
 
   $ hg fix -r . -r '.^' --working-dir
 
   $ hg parents --template '{rev}\n'
   4
   $ hg cat -r '.^^' file.changed
   first
   second
   third
   fourth
   fifth
   $ hg cat -r '.^' file.changed
   FIRST (CHANGED)
   second
   third
   fourth
   fifth
   $ hg cat -r . file.changed
   FIRST (CHANGED)
   second
   THIRD (CHANGED)
   fourth
   fifth
   $ cat file.changed
   FIRST (CHANGED)
   second
   THIRD (CHANGED)
   fourth
   FIFTH (CHANGED)
 
   $ cd ..
 
 If we incrementally fix a merge commit, we should fix any lines that changed
 versus either parent. You could imagine only fixing the intersection or some
 other subset, but this is necessary if either parent is being fixed. It
 prevents us from forgetting fixes made in either parent.
 
   $ hg init incrementallyfixmergecommit
   $ cd incrementallyfixmergecommit
 
   $ printf "a\nb\nc\n" > file.changed
   $ hg commit -Aqm "ancestor"
 
   $ printf "aa\nb\nc\n" > file.changed
   $ hg commit -m "change a"
 
   $ hg checkout '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ printf "a\nb\ncc\n" > file.changed
   $ hg commit -m "change c"
   created new head
 
   $ hg merge
   merging file.changed
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m "merge"
   $ hg cat -r . file.changed
   aa
   b
   cc
 
   $ hg fix -r . --working-dir
   $ hg cat -r . file.changed
   AA
   b
   CC
 
   $ cd ..
 
 Abort fixing revisions if there is an unfinished operation. We don't want to
 make things worse by editing files or stripping/obsoleting things. Also abort
 fixing the working directory if there are unresolved merge conflicts.
 
   $ hg init abortunresolved
   $ cd abortunresolved
 
   $ echo "foo1" > foo.whole
   $ hg commit -Aqm "foo 1"
 
   $ hg update null
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo "foo2" > foo.whole
   $ hg commit -Aqm "foo 2"
 
   $ hg --config extensions.rebase= rebase -r 1 -d 0
   rebasing 1:c3b6dc0e177a tip "foo 2"
   merging foo.whole
   warning: conflicts while merging foo.whole! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
 
   $ hg --config extensions.rebase= fix --working-dir
   abort: unresolved conflicts
   (use 'hg resolve')
   [255]
 
   $ hg --config extensions.rebase= fix -r .
   abort: rebase in progress
   (use 'hg rebase --continue', 'hg rebase --abort', or 'hg rebase --stop')
   [20]
 
   $ cd ..
 
 When fixing a file that was renamed, we should diff against the source of the
 rename for incremental fixing and we should correctly reproduce the rename in
 the replacement revision.
 
   $ hg init fixrenamecommit
   $ cd fixrenamecommit
 
   $ printf "a\nb\nc\n" > source.changed
   $ hg commit -Aqm "source revision"
   $ hg move source.changed dest.changed
   $ printf "a\nb\ncc\n" > dest.changed
   $ hg commit -m "dest revision"
 
   $ hg fix -r .
   $ hg log -r tip --copies --template "{file_copies}\n"
   dest.changed (source.changed)
   $ hg cat -r tip dest.changed
   a
   b
   CC
 
   $ cd ..
 
 When fixing revisions that remove files we must ensure that the replacement
 actually removes the file, whereas it could accidentally leave it unchanged or
 write an empty string to it.
 
   $ hg init fixremovedfile
   $ cd fixremovedfile
 
   $ printf "foo\n" > foo.whole
   $ printf "bar\n" > bar.whole
   $ hg commit -Aqm "add files"
   $ hg remove bar.whole
   $ hg commit -m "remove file"
   $ hg status --change .
   R bar.whole
   $ hg fix -r . foo.whole
   $ hg status --change tip
   M foo.whole
   R bar.whole
 
   $ cd ..
 
 If fixing a revision finds no fixes to make, no replacement revision should be
 created.
 
   $ hg init nofixesneeded
   $ cd nofixesneeded
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add file"
   $ hg log --template '{rev}\n'
   0
   $ hg fix -r .
   $ hg log --template '{rev}\n'
   0
 
   $ cd ..
 
 If fixing a commit reverts all the changes in the commit, we replace it with a
 commit that changes no files.
 
   $ hg init nochangesleft
   $ cd nochangesleft
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add file"
   $ printf "foo\n" > foo.whole
   $ hg commit -m "edit file"
   $ hg status --change .
   M foo.whole
   $ hg fix -r .
   $ hg status --change tip
 
   $ cd ..
 
 If we fix a parent and child revision together, the child revision must be
 replaced if the parent is replaced, even if the diffs of the child needed no
 fixes. However, we're free to not replace revisions that need no fixes and have
 no ancestors that are replaced.
 
   $ hg init mustreplacechild
   $ cd mustreplacechild
 
   $ printf "FOO\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ printf "foo\n" > foo.whole
   $ hg commit -m "edit foo"
   $ printf "BAR\n" > bar.whole
   $ hg commit -Aqm "add bar"
 
   $ hg log --graph --template '{rev} {files}'
   @  2 bar.whole
   |
   o  1 foo.whole
   |
   o  0 foo.whole
   
   $ hg fix -r 0:2
   $ hg log --graph --template '{rev} {files}'
   o  4 bar.whole
   |
   o  3
   |
   | @  2 bar.whole
   | |
   | x  1 foo.whole
   |/
   o  0 foo.whole
   
 
   $ cd ..
 
 It's also possible that the child needs absolutely no changes, but we still
 need to replace it to update its parent. If we skipped replacing the child
 because it had no file content changes, it would become an orphan for no good
 reason.
 
   $ hg init mustreplacechildevenifnop
   $ cd mustreplacechildevenifnop
 
   $ printf "Foo\n" > foo.whole
   $ hg commit -Aqm "add a bad foo"
   $ printf "FOO\n" > foo.whole
   $ hg commit -m "add a good foo"
   $ hg fix -r . -r '.^'
   $ hg log --graph --template '{rev} {desc}'
   o  3 add a good foo
   |
   o  2 add a bad foo
   
   @  1 add a good foo
   |
   x  0 add a bad foo
   
 
   $ cd ..
 
 Similar to the case above, the child revision may become empty as a result of
 fixing its parent. We should still create an empty replacement child.
 TODO: determine how this should interact with ui.allowemptycommit given that
 the empty replacement could have children.
 
   $ hg init mustreplacechildevenifempty
   $ cd mustreplacechildevenifempty
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ printf "Foo\n" > foo.whole
   $ hg commit -m "edit foo"
   $ hg fix -r . -r '.^'
   $ hg log --graph --template '{rev} {desc}\n' --stat
   o  3 edit foo
   |
   o  2 add foo
       foo.whole |  1 +
       1 files changed, 1 insertions(+), 0 deletions(-)
   
   @  1 edit foo
   |   foo.whole |  2 +-
   |   1 files changed, 1 insertions(+), 1 deletions(-)
   |
   x  0 add foo
       foo.whole |  1 +
       1 files changed, 1 insertions(+), 0 deletions(-)
   
 
   $ cd ..
 
 Fixing a secret commit should replace it with another secret commit.
 
   $ hg init fixsecretcommit
   $ cd fixsecretcommit
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo" --secret
   $ hg fix -r .
   $ hg log --template '{rev} {phase}\n'
   1 secret
   0 secret
 
   $ cd ..
 
 We should also preserve phase when fixing a draft commit while the user has
 their default set to secret.
 
   $ hg init respectphasesnewcommit
   $ cd respectphasesnewcommit
 
   $ printf "foo\n" > foo.whole
   $ hg commit -Aqm "add foo"
   $ hg --config phases.newcommit=secret fix -r .
   $ hg log --template '{rev} {phase}\n'
   1 draft
   0 draft
 
   $ cd ..
 
 Debug output should show what fixer commands are being subprocessed, which is
 useful for anyone trying to set up a new config.
 
   $ hg init debugoutput
   $ cd debugoutput
 
   $ printf "foo\nbar\nbaz\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ printf "Foo\nbar\nBaz\n" > foo.changed
   $ hg --debug fix --working-dir
   subprocess: * $TESTTMP/uppercase.py 1-1 3-3 (glob)
 
   $ cd ..
 
 Fixing an obsolete revision can cause divergence, so we abort unless the user
 configures to allow it. This is not yet smart enough to know whether there is a
 successor, but even then it is not likely intentional or idiomatic to fix an
 obsolete revision.
 
   $ hg init abortobsoleterev
   $ cd abortobsoleterev
 
   $ printf "foo\n" > foo.changed
   $ hg commit -Aqm "foo"
   $ hg debugobsolete `hg parents --template '{node}'`
   1 new obsolescence markers
   obsoleted 1 changesets
   $ hg --hidden fix -r 0
   abort: fixing obsolete revision could cause divergence
   [255]
 
   $ hg --hidden fix -r 0 --config experimental.evolution.allowdivergence=true
   $ hg cat -r tip foo.changed
   FOO
 
   $ cd ..
 
 Test all of the available substitution values for fixer commands.
 
   $ hg init substitution
   $ cd substitution
 
   $ mkdir foo
   $ printf "hello\ngoodbye\n" > foo/bar
   $ hg add
   adding foo/bar
   $ hg --config "fix.fail:command=printf '%s\n' '{rootpath}' '{basename}'" \
   >    --config "fix.fail:linerange='{first}' '{last}'" \
   >    --config "fix.fail:pattern=foo/bar" \
   >    fix --working-dir
   $ cat foo/bar
   foo/bar
   bar
   1
   2
 
   $ cd ..
 
 The --base flag should allow picking the revisions to diff against for changed
 files and incremental line formatting.
 
   $ hg init baseflag
   $ cd baseflag
 
   $ printf "one\ntwo\n" > foo.changed
   $ printf "bar\n" > bar.changed
   $ hg commit -Aqm "first"
   $ printf "one\nTwo\n" > foo.changed
   $ hg commit -m "second"
   $ hg fix -w --base .
   $ hg status
   $ hg fix -w --base null
   $ cat foo.changed
   ONE
   TWO
   $ cat bar.changed
   BAR
 
   $ cd ..
 
 If the user asks to fix the parent of another commit, they are asking to create
 an orphan. We must respect experimental.evolution.allowunstable.
 
   $ hg init allowunstable
   $ cd allowunstable
 
   $ printf "one\n" > foo.whole
   $ hg commit -Aqm "first"
   $ printf "two\n" > foo.whole
   $ hg commit -m "second"
   $ hg --config experimental.evolution.allowunstable=False fix -r '.^'
   abort: cannot fix changeset with children
-  [255]
+  [10]
   $ hg fix -r '.^'
   1 new orphan changesets
   $ hg cat -r 2 foo.whole
   ONE
 
   $ cd ..
 
 The --base flag affects the set of files being fixed. So while the --whole flag
 makes the base irrelevant for changed line ranges, it still changes the
 meaning and effect of the command. In this example, no files or lines are fixed
 until we specify the base, but then we do fix unchanged lines.
 
   $ hg init basewhole
   $ cd basewhole
   $ printf "foo1\n" > foo.changed
   $ hg commit -Aqm "first"
   $ printf "foo2\n" >> foo.changed
   $ printf "bar\n" > bar.changed
   $ hg commit -Aqm "second"
 
   $ hg fix --working-dir --whole
   $ cat *.changed
   bar
   foo1
   foo2
 
   $ hg fix --working-dir --base 0 --whole
   $ cat *.changed
   BAR
   FOO1
   FOO2
 
   $ cd ..
 
 The execution order of tools can be controlled. This example doesn't work if
 you sort after truncating, but the config defines the correct order while the
 definitions are out of order (which might imply the incorrect order given the
 implementation of fix). The goal is to use multiple tools to select the lowest
 5 numbers in the file.
 
   $ hg init priorityexample
   $ cd priorityexample
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > head:command = head -n 5
   > head:pattern = numbers.txt
   > head:priority = 1
   > sort:command = sort -n
   > sort:pattern = numbers.txt
   > sort:priority = 2
   > EOF
 
   $ printf "8\n2\n3\n6\n7\n4\n9\n5\n1\n0\n" > numbers.txt
   $ hg add -q
   $ hg fix -w
   $ cat numbers.txt
   0
   1
   2
   3
   4
 
 And of course we should be able to break this by reversing the execution order.
 Test negative priorities while we're at it.
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > head:priority = -1
   > sort:priority = -2
   > EOF
   $ printf "8\n2\n3\n6\n7\n4\n9\n5\n1\n0\n" > numbers.txt
   $ hg fix -w
   $ cat numbers.txt
   2
   3
   6
   7
   8
 
   $ cd ..
 
 It's possible for repeated applications of a fixer tool to create cycles in the
 generated content of a file. For example, two users with different versions of
 a code formatter might fight over the formatting when they run hg fix. In the
 absence of other changes, this means we could produce commits with the same
 hash in subsequent runs of hg fix. This is a problem unless we support
 obsolescence cycles well. We avoid this by adding an extra field to the
 successor which forces it to have a new hash. That's why this test creates
 three revisions instead of two.
 
   $ hg init cyclictool
   $ cd cyclictool
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > swapletters:command = tr ab ba
   > swapletters:pattern = foo
   > EOF
 
   $ echo ab > foo
   $ hg commit -Aqm foo
 
   $ hg fix -r 0
   $ hg fix -r 1
 
   $ hg cat -r 0 foo --hidden
   ab
   $ hg cat -r 1 foo --hidden
   ba
   $ hg cat -r 2 foo
   ab
 
   $ cd ..
 
 We run fixer tools in the repo root so they can look for config files or other
 important things in the working directory. This does NOT mean we are
 reconstructing a working copy of every revision being fixed; we're just giving
 the tool knowledge of the repo's location in case it can do something
 reasonable with that.
 
   $ hg init subprocesscwd
   $ cd subprocesscwd
 
   $ cat >> .hg/hgrc <<EOF
   > [fix]
   > printcwd:command = "$PYTHON" -c "import os; print(os.getcwd())"
   > printcwd:pattern = relpath:foo/bar
   > filesetpwd:command = "$PYTHON" -c "import os; print('fs: ' + os.getcwd())"
   > filesetpwd:pattern = set:**quux
   > EOF
 
   $ mkdir foo
   $ printf "bar\n" > foo/bar
   $ printf "quux\n" > quux
   $ hg commit -Aqm blah
 
   $ hg fix -w -r . foo/bar
   $ hg cat -r tip foo/bar
   $TESTTMP/subprocesscwd
   $ cat foo/bar
   $TESTTMP/subprocesscwd
 
   $ cd foo
 
   $ hg fix -w -r . bar
   $ hg cat -r tip bar ../quux
   $TESTTMP/subprocesscwd
   quux
   $ cat bar ../quux
   $TESTTMP/subprocesscwd
   quux
   $ echo modified > bar
   $ hg fix -w bar
   $ cat bar
   $TESTTMP/subprocesscwd
 
 Apparently fixing p1() and its descendants doesn't include wdir() unless
 explicitly stated.
 
   $ hg fix -r '.::'
   $ hg cat -r . ../quux
   quux
   $ hg cat -r tip ../quux
   fs: $TESTTMP/subprocesscwd
   $ cat ../quux
   quux
 
 Clean files are not fixed unless explicitly named
   $ echo 'dirty' > ../quux
 
   $ hg fix --working-dir
   $ cat ../quux
   fs: $TESTTMP/subprocesscwd
 
   $ cd ../..
 
 Tools configured without a pattern are ignored. It would be too dangerous to
 run them on all files, because this might happen while testing a configuration
 that also deletes all of the file content. There is no reasonable subset of the
 files to use as a default. Users should be explicit about what files are
 affected by a tool. This test also confirms that we don't crash when the
 pattern config is missing, and that we only warn about it once.
 
   $ hg init nopatternconfigured
   $ cd nopatternconfigured
 
   $ printf "foo" > foo
   $ printf "bar" > bar
   $ hg add -q
   $ hg fix --debug --working-dir --config "fix.nopattern:command=echo fixed"
   fixer tool has no pattern configuration: nopattern
   $ cat foo bar
   foobar (no-eol)
   $ hg fix --debug --working-dir --config "fix.nocommand:pattern=foo.bar"
   fixer tool has no command configuration: nocommand
 
   $ cd ..
 
 Tools can be disabled. Disabled tools do nothing but print a debug message.
 
   $ hg init disabled
   $ cd disabled
 
   $ printf "foo\n" > foo
   $ hg add -q
   $ hg fix --debug --working-dir --config "fix.disabled:command=echo fixed" \
   >                              --config "fix.disabled:pattern=foo" \
   >                              --config "fix.disabled:enabled=false"
   ignoring disabled fixer tool: disabled
   $ cat foo
   foo
 
   $ cd ..
 
 Test that we can configure a fixer to affect all files regardless of the cwd.
 The way we invoke matching must not prohibit this.
 
   $ hg init affectallfiles
   $ cd affectallfiles
 
   $ mkdir foo bar
   $ printf "foo" > foo/file
   $ printf "bar" > bar/file
   $ printf "baz" > baz_file
   $ hg add -q
 
   $ cd bar
   $ hg fix --working-dir --config "fix.cooltool:command=echo fixed" \
   >                      --config "fix.cooltool:pattern=glob:**"
   $ cd ..
 
   $ cat foo/file
   fixed
   $ cat bar/file
   fixed
   $ cat baz_file
   fixed
 
   $ cd ..
 
 Tools should be able to run on unchanged files, even if they set :linerange.
 This includes a corner case where deleted chunks of a file are not considered
 changes.
 
   $ hg init skipclean
   $ cd skipclean
 
   $ printf "a\nb\nc\n" > foo
   $ printf "a\nb\nc\n" > bar
   $ printf "a\nb\nc\n" > baz
   $ hg commit -Aqm "base"
 
   $ printf "a\nc\n" > foo
   $ printf "a\nx\nc\n" > baz
 
   $ cat >> print.py <<EOF
   > import sys
   > for a in sys.argv[1:]:
   >    print(a)
   > EOF
 
   $ hg fix --working-dir foo bar baz \
   >        --config "fix.changedlines:command=\"$PYTHON\" print.py \"Line ranges:\"" \
   >        --config 'fix.changedlines:linerange="{first} through {last}"' \
   >        --config 'fix.changedlines:pattern=glob:**' \
   >        --config 'fix.changedlines:skipclean=false'
 
   $ cat foo
   Line ranges:
   $ cat bar
   Line ranges:
   $ cat baz
   Line ranges:
   2 through 2
 
   $ cd ..
 
 Test various cases around merges. We were previously dropping files if they were
 created on only the p2 side of the merge, so let's test permutations of:
 *   added, was fixed
 *   added, considered for fixing but was already good
 *   added, not considered for fixing
 *   modified, was fixed
 *   modified, considered for fixing but was already good
 *   modified, not considered for fixing
 
 Before the bug was fixed where we would drop files, this test demonstrated the
 following issues:
 *   new_in_r1.ignored, new_in_r1_already_good.changed, and
 >   mod_in_r1_already_good.changed were NOT in the manifest for the merge commit
 *   mod_in_r1.ignored had its contents from r0, NOT r1.
 
 We're also setting a named branch for every commit to demonstrate that the
 branch is kept intact and there aren't issues updating to another branch in the
 middle of fix.
 
   $ hg init merge_keeps_files
   $ cd merge_keeps_files
   $ for f in r0 mod_in_r1 mod_in_r2 mod_in_merge mod_in_child; do
   >   for c in changed whole ignored; do
   >     printf "hello\n" > $f.$c
   >   done
   >   printf "HELLO\n" > "mod_in_${f}_already_good.changed"
   > done
   $ hg branch -q r0
   $ hg ci -Aqm 'r0'
   $ hg phase -p
   $ make_test_files() {
   >   printf "world\n" >> "mod_in_$1.changed"
   >   printf "world\n" >> "mod_in_$1.whole"
   >   printf "world\n" >> "mod_in_$1.ignored"
   >   printf "WORLD\n" >> "mod_in_$1_already_good.changed"
   >   printf "new in $1\n" > "new_in_$1.changed"
   >   printf "new in $1\n" > "new_in_$1.whole"
   >   printf "new in $1\n" > "new_in_$1.ignored"
   >   printf "ALREADY GOOD, NEW IN THIS REV\n" > "new_in_$1_already_good.changed"
   > }
   $ make_test_commit() {
   >   make_test_files "$1"
   >   hg branch -q "$1"
   >   hg ci -Aqm "$2"
   > }
   $ make_test_commit r1 "merge me, pt1"
   $ hg co -q ".^"
   $ make_test_commit r2 "merge me, pt2"
   $ hg merge -qr 1
   $ make_test_commit merge "evil merge"
   $ make_test_commit child "child of merge"
   $ make_test_files wdir
   $ hg fix -r 'not public()' -w
   $ hg log -G -T'{rev}:{shortest(node,8)}: branch:{branch} desc:{desc}'
   @  8:c22ce900: branch:child desc:child of merge
   |
   o    7:5a30615a: branch:merge desc:evil merge
   |\
   | o  6:4e5acdc4: branch:r2 desc:merge me, pt2
   | |
   o |  5:eea01878: branch:r1 desc:merge me, pt1
   |/
   o  0:0c548d87: branch:r0 desc:r0
   
   $ hg files -r tip
   mod_in_child.changed
   mod_in_child.ignored
   mod_in_child.whole
   mod_in_child_already_good.changed
   mod_in_merge.changed
   mod_in_merge.ignored
   mod_in_merge.whole
   mod_in_merge_already_good.changed
   mod_in_mod_in_child_already_good.changed
   mod_in_mod_in_merge_already_good.changed
   mod_in_mod_in_r1_already_good.changed
   mod_in_mod_in_r2_already_good.changed
   mod_in_r0_already_good.changed
   mod_in_r1.changed
   mod_in_r1.ignored
   mod_in_r1.whole
   mod_in_r1_already_good.changed
   mod_in_r2.changed
   mod_in_r2.ignored
   mod_in_r2.whole
   mod_in_r2_already_good.changed
   new_in_child.changed
   new_in_child.ignored
   new_in_child.whole
   new_in_child_already_good.changed
   new_in_merge.changed
   new_in_merge.ignored
   new_in_merge.whole
   new_in_merge_already_good.changed
   new_in_r1.changed
   new_in_r1.ignored
   new_in_r1.whole
   new_in_r1_already_good.changed
   new_in_r2.changed
   new_in_r2.ignored
   new_in_r2.whole
   new_in_r2_already_good.changed
   r0.changed
   r0.ignored
   r0.whole
   $ for f in "$(hg files -r tip)"; do hg cat -r tip $f -T'{path}:\n{data}\n'; done
   mod_in_child.changed:
   hello
   WORLD
   
   mod_in_child.ignored:
   hello
   world
   
   mod_in_child.whole:
   HELLO
   WORLD
   
   mod_in_child_already_good.changed:
   WORLD
   
   mod_in_merge.changed:
   hello
   WORLD
   
   mod_in_merge.ignored:
   hello
   world
   
   mod_in_merge.whole:
   HELLO
   WORLD
   
   mod_in_merge_already_good.changed:
   WORLD
   
   mod_in_mod_in_child_already_good.changed:
   HELLO
   
   mod_in_mod_in_merge_already_good.changed:
   HELLO
   
   mod_in_mod_in_r1_already_good.changed:
   HELLO
   
   mod_in_mod_in_r2_already_good.changed:
   HELLO
   
   mod_in_r0_already_good.changed:
   HELLO
   
   mod_in_r1.changed:
   hello
   WORLD
   
   mod_in_r1.ignored:
   hello
   world
   
   mod_in_r1.whole:
   HELLO
   WORLD
   
   mod_in_r1_already_good.changed:
   WORLD
   
   mod_in_r2.changed:
   hello
   WORLD
   
   mod_in_r2.ignored:
   hello
   world
   
   mod_in_r2.whole:
   HELLO
   WORLD
   
   mod_in_r2_already_good.changed:
   WORLD
   
   new_in_child.changed:
   NEW IN CHILD
   
   new_in_child.ignored:
   new in child
   
   new_in_child.whole:
   NEW IN CHILD
   
   new_in_child_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_merge.changed:
   NEW IN MERGE
   
   new_in_merge.ignored:
   new in merge
   
   new_in_merge.whole:
   NEW IN MERGE
   
   new_in_merge_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_r1.changed:
   NEW IN R1
   
   new_in_r1.ignored:
   new in r1
   
   new_in_r1.whole:
   NEW IN R1
   
   new_in_r1_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   new_in_r2.changed:
   NEW IN R2
   
   new_in_r2.ignored:
   new in r2
   
   new_in_r2.whole:
   NEW IN R2
   
   new_in_r2_already_good.changed:
   ALREADY GOOD, NEW IN THIS REV
   
   r0.changed:
   hello
   
   r0.ignored:
   hello
   
   r0.whole:
   hello
   

tests/test-histedit-obsolete.t

@@ -1,591 +1,591 b''
 #testcases abortcommand abortflag
 
 #if abortflag
   $ cat >> $HGRCPATH <<EOF
   > [alias]
   > abort = histedit --abort
   > EOF
 #endif
 
   $ . "$TESTDIR/histedit-helpers.sh"
 
 Enable obsolete
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > logtemplate= {rev}:{node|short} {desc|firstline}
   > [phases]
   > publish=False
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > [extensions]
   > histedit=
   > rebase=
   > EOF
 
 Test that histedit learns about obsolescence not stored in histedit state
   $ hg init boo
   $ cd boo
   $ echo a > a
   $ hg ci -Am a
   adding a
   $ echo a > b
   $ echo a > c
   $ echo a > c
   $ hg ci -Am b
   adding b
   adding c
   $ echo a > d
   $ hg ci -Am c
   adding d
   $ echo "pick `hg log -r 0 -T '{node|short}'`" > plan
   $ echo "pick `hg log -r 2 -T '{node|short}'`" >> plan
   $ echo "edit `hg log -r 1 -T '{node|short}'`" >> plan
   $ hg histedit -r 'all()' --commands plan
   Editing (1b2d564fad96), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ hg st
   A b
   A c
   ? plan
   $ hg commit --amend b
   $ hg histedit --continue
   $ hg log -G
   @  5:46abc7c4d873 b
   |
   o  4:49d44ab2be1b c
   |
   o  0:cb9a9f314b8b a
   
   $ hg debugobsolete
   e72d22b19f8ecf4150ab4f91d0973fd9955d3ddf 49d44ab2be1b67a79127568a67c9c99430633b48 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'operation': 'amend', 'user': 'test'}
   1b2d564fad96311b45362f17c2aa855150efb35f 46abc7c4d8738e8563e577f7889e1b6db3da4199 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '12', 'operation': 'histedit', 'user': 'test'}
   114f4176969ef342759a8a57e6bccefc4234829b 49d44ab2be1b67a79127568a67c9c99430633b48 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '12', 'operation': 'histedit', 'user': 'test'}
 
 With some node gone missing during the edit.
 
   $ echo "pick `hg log -r 0 -T '{node|short}'`" > plan
   $ echo "pick `hg log -r 5 -T '{node|short}'`" >> plan
   $ echo "edit `hg log -r 4 -T '{node|short}'`" >> plan
   $ hg histedit -r 'all()' --commands plan
   Editing (49d44ab2be1b), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ hg st
   A b
   A d
   ? plan
   $ hg commit --amend -X . -m XXXXXX
   $ hg commit --amend -X . -m b2
   $ hg --hidden --config extensions.strip= strip 'desc(XXXXXX)' --no-backup
   $ hg histedit --continue
   $ hg log -G
   @  8:273c1f3b8626 c
   |
   o  7:aba7da937030 b2
   |
   o  0:cb9a9f314b8b a
   
   $ hg debugobsolete
   e72d22b19f8ecf4150ab4f91d0973fd9955d3ddf 49d44ab2be1b67a79127568a67c9c99430633b48 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '8', 'operation': 'amend', 'user': 'test'}
   1b2d564fad96311b45362f17c2aa855150efb35f 46abc7c4d8738e8563e577f7889e1b6db3da4199 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '12', 'operation': 'histedit', 'user': 'test'}
   114f4176969ef342759a8a57e6bccefc4234829b 49d44ab2be1b67a79127568a67c9c99430633b48 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '12', 'operation': 'histedit', 'user': 'test'}
   76f72745eac0643d16530e56e2f86e36e40631f1 2ca853e48edbd6453a0674dc0fe28a0974c51b9c 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   2ca853e48edbd6453a0674dc0fe28a0974c51b9c aba7da93703075eec9fb1dbaf143ff2bc1c49d46 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   49d44ab2be1b67a79127568a67c9c99430633b48 273c1f3b86267ed3ec684bb13af1fa4d6ba56e02 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'histedit', 'user': 'test'}
   46abc7c4d8738e8563e577f7889e1b6db3da4199 aba7da93703075eec9fb1dbaf143ff2bc1c49d46 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '5', 'operation': 'histedit', 'user': 'test'}
   $ cd ..
 
 Base setup for the rest of the testing
 ======================================
 
   $ hg init base
   $ cd base
 
   $ for x in a b c d e f ; do
   >     echo $x > $x
   >     hg add $x
   >     hg ci -m $x
   > done
 
   $ hg log --graph
   @  5:652413bf663e f
   |
   o  4:e860deea161a e
   |
   o  3:055a42cdd887 d
   |
   o  2:177f92b77385 c
   |
   o  1:d2ae7f538514 b
   |
   o  0:cb9a9f314b8b a
   
 
   $ HGEDITOR=cat hg histedit 1
   pick d2ae7f538514 1 b
   pick 177f92b77385 2 c
   pick 055a42cdd887 3 d
   pick e860deea161a 4 e
   pick 652413bf663e 5 f
   
   # Edit history between d2ae7f538514 and 652413bf663e
   #
   # Commits are listed from least to most recent
   #
   # You can reorder changesets by reordering the lines
   #
   # Commands:
   #
   #  e, edit = use commit, but stop for amending
   #  m, mess = edit commit message without changing commit content
   #  p, pick = use commit
   #  b, base = checkout changeset and apply further changesets from there
   #  d, drop = remove commit from history
   #  f, fold = use commit, but combine it with the one above
   #  r, roll = like fold, but discard this commit's description and date
   #
   $ hg histedit 1 --commands - --verbose <<EOF | grep histedit
   > pick 177f92b77385 2 c
   > drop d2ae7f538514 1 b
   > pick 055a42cdd887 3 d
   > fold e860deea161a 4 e
   > pick 652413bf663e 5 f
   > EOF
   [1]
   $ hg log --graph --hidden
   @  10:cacdfd884a93 f
   |
   o  9:59d9f330561f d
   |
   | x  8:b558abc46d09 fold-temp-revision e860deea161a
   | |
   | x  7:96e494a2d553 d
   |/
   o  6:b346ab9a313d c
   |
   | x  5:652413bf663e f
   | |
   | x  4:e860deea161a e
   | |
   | x  3:055a42cdd887 d
   | |
   | x  2:177f92b77385 c
   | |
   | x  1:d2ae7f538514 b
   |/
   o  0:cb9a9f314b8b a
   
   $ hg debugobsolete
   d2ae7f538514cd87c17547b0de4cea71fe1af9fb 0 {cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'histedit', 'user': 'test'}
   177f92b773850b59254aa5e923436f921b55483b b346ab9a313db8537ecf96fca3ca3ca984ef3bd7 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'histedit', 'user': 'test'}
   055a42cdd88768532f9cf79daa407fc8d138de9b 59d9f330561fd6c88b1a6b32f0e45034d88db784 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'histedit', 'user': 'test'}
   e860deea161a2f77de56603b340ebbb4536308ae 59d9f330561fd6c88b1a6b32f0e45034d88db784 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'histedit', 'user': 'test'}
   652413bf663ef2a641cab26574e46d5f5a64a55a cacdfd884a9321ec4e1de275ef3949fa953a1f83 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'histedit', 'user': 'test'}
   96e494a2d553dd05902ba1cee1d94d4cb7b8faed 0 {b346ab9a313db8537ecf96fca3ca3ca984ef3bd7} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'histedit', 'user': 'test'}
   b558abc46d09c30f57ac31e85a8a3d64d2e906e4 0 {96e494a2d553dd05902ba1cee1d94d4cb7b8faed} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'histedit', 'user': 'test'}
 
 
 Ensure hidden revision does not prevent histedit
 -------------------------------------------------
 
 create an hidden revision
 
   $ hg histedit 6 --commands - << EOF
   > pick b346ab9a313d 6 c
   > drop 59d9f330561f 7 d
   > pick cacdfd884a93 8 f
   > EOF
   $ hg log --graph
   @  11:c13eb81022ca f
   |
   o  6:b346ab9a313d c
   |
   o  0:cb9a9f314b8b a
   
 check hidden revision are ignored (6 have hidden children 7 and 8)
 
   $ hg histedit 6 --commands - << EOF
   > pick b346ab9a313d 6 c
   > pick c13eb81022ca 8 f
   > EOF
 
 
 
 Test that rewriting leaving instability behind is allowed
 ---------------------------------------------------------------------
 
   $ hg up '.^'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -r 'children(.)'
   11:c13eb81022ca f (no-eol)
   $ hg histedit -r '.' --commands - <<EOF
   > edit b346ab9a313d 6 c
   > EOF
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   Editing (b346ab9a313d), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ echo c >> c
   $ hg histedit --continue
   1 new orphan changesets
 
   $ hg log -r 'orphan()'
   11:c13eb81022ca f (no-eol)
 
 stabilise
 
   $ hg rebase  -r 'orphan()' -d .
   rebasing 11:c13eb81022ca "f"
   $ hg up tip -q
 
 Test dropping of changeset on the top of the stack
 -------------------------------------------------------
 
 Nothing is rewritten below, the working directory parent must be change for the
 dropped changeset to be hidden.
 
   $ cd ..
   $ hg clone base droplast
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd droplast
   $ hg histedit -r '40db8afa467b' --commands - << EOF
   > pick 40db8afa467b 10 c
   > drop b449568bf7fc 11 f
   > EOF
   $ hg log -G
   @  12:40db8afa467b c
   |
   o  0:cb9a9f314b8b a
   
 
 With rewritten ancestors
 
   $ echo e > e
   $ hg add e
   $ hg commit -m g
   $ echo f > f
   $ hg add f
   $ hg commit -m h
   $ hg histedit -r '40db8afa467b' --commands - << EOF
   > pick 47a8561c0449 12 g
   > pick 40db8afa467b 10 c
   > drop 1b3b05f35ff0 13 h
   > EOF
   $ hg log -G
   @  17:ee6544123ab8 c
   |
   o  16:269e713e9eae g
   |
   o  0:cb9a9f314b8b a
   
   $ cd ../base
 
 
 
 Test phases support
 ===========================================
 
 Check that histedit respect immutability
 -------------------------------------------
 
   $ cat >> $HGRCPATH << EOF
   > [command-templates]
   > log = {rev}:{node|short} ({phase}) {desc|firstline}\n
   > EOF
 
   $ hg ph -pv '.^'
   phase changed for 2 changesets
   $ hg log -G
   @  13:b449568bf7fc (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ hg histedit -r '.~2'
   abort: cannot edit public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
 
 
 Prepare further testing
 -------------------------------------------
 
   $ for x in g h i j k ; do
   >     echo $x > $x
   >     hg add $x
   >     hg ci -m $x
   > done
   $ hg phase --force --secret .~2
   $ hg log -G
   @  18:ee118ab9fa44 (secret) k
   |
   o  17:3a6c53ee7f3d (secret) j
   |
   o  16:b605fb7503f2 (secret) i
   |
   o  15:7395e1ff83bd (draft) h
   |
   o  14:6b70183d2492 (draft) g
   |
   o  13:b449568bf7fc (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ cd ..
 
 simple phase conservation
 -------------------------------------------
 
 Resulting changeset should conserve the phase of the original one whatever the
 phases.new-commit option is.
 
 New-commit as draft (default)
 
   $ cp -R base simple-draft
   $ cd simple-draft
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF
   > edit b449568bf7fc 11 f
   > pick 6b70183d2492 12 g
   > pick 7395e1ff83bd 13 h
   > pick b605fb7503f2 14 i
   > pick 3a6c53ee7f3d 15 j
   > pick ee118ab9fa44 16 k
   > EOF
   0 files updated, 0 files merged, 6 files removed, 0 files unresolved
   Editing (b449568bf7fc), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ echo f >> f
   $ hg histedit --continue
   $ hg log -G
   @  24:12e89af74238 (secret) k
   |
   o  23:636a8687b22e (secret) j
   |
   o  22:ccaf0a38653f (secret) i
   |
   o  21:11a89d1c2613 (draft) h
   |
   o  20:c1dec7ca82ea (draft) g
   |
   o  19:087281e68428 (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ cd ..
 
 
 New-commit as secret (config)
 
   $ cp -R base simple-secret
   $ cd simple-secret
   $ cat >> .hg/hgrc << EOF
   > [phases]
   > new-commit=secret
   > EOF
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF
   > edit b449568bf7fc 11 f
   > pick 6b70183d2492 12 g
   > pick 7395e1ff83bd 13 h
   > pick b605fb7503f2 14 i
   > pick 3a6c53ee7f3d 15 j
   > pick ee118ab9fa44 16 k
   > EOF
   0 files updated, 0 files merged, 6 files removed, 0 files unresolved
   Editing (b449568bf7fc), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ echo f >> f
   $ hg histedit --continue
   $ hg log -G
   @  24:12e89af74238 (secret) k
   |
   o  23:636a8687b22e (secret) j
   |
   o  22:ccaf0a38653f (secret) i
   |
   o  21:11a89d1c2613 (draft) h
   |
   o  20:c1dec7ca82ea (draft) g
   |
   o  19:087281e68428 (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ cd ..
 
 
 Changeset reordering
 -------------------------------------------
 
 If a secret changeset is put before a draft one, all descendant should be secret.
 It seems more important to present the secret phase.
 
   $ cp -R base reorder
   $ cd reorder
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF
   > pick b449568bf7fc 11 f
   > pick 3a6c53ee7f3d 15 j
   > pick 6b70183d2492 12 g
   > pick b605fb7503f2 14 i
   > pick 7395e1ff83bd 13 h
   > pick ee118ab9fa44 16 k
   > EOF
   $ hg log -G
   @  23:558246857888 (secret) k
   |
   o  22:28bd44768535 (secret) h
   |
   o  21:d5395202aeb9 (secret) i
   |
   o  20:21edda8e341b (secret) g
   |
   o  19:5ab64f3a4832 (secret) j
   |
   o  13:b449568bf7fc (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ cd ..
 
 Changeset folding
 -------------------------------------------
 
 Folding a secret changeset with a draft one turn the result secret (again,
 better safe than sorry). Folding between same phase changeset still works
 
 Note that there is a few reordering in this series for more extensive test
 
   $ cp -R base folding
   $ cd folding
   $ cat >> .hg/hgrc << EOF
   > [phases]
   > new-commit=secret
   > EOF
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF
   > pick 7395e1ff83bd 13 h
   > fold b449568bf7fc 11 f
   > pick 6b70183d2492 12 g
   > fold 3a6c53ee7f3d 15 j
   > pick b605fb7503f2 14 i
   > fold ee118ab9fa44 16 k
   > EOF
   $ hg log -G
   @  27:f9daec13fb98 (secret) i
   |
   o  24:49807617f46a (secret) g
   |
   o  21:050280826e04 (draft) h
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ hg co 49807617f46a
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo wat >> wat
   $ hg add wat
   $ hg ci -m 'add wat'
   created new head
   $ hg merge f9daec13fb98
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge'
   $ echo not wat > wat
   $ hg ci -m 'modify wat'
   $ hg histedit 050280826e04
   abort: cannot edit history that contains merges
   [255]
   $ cd ..
 
 Check abort behavior
 -------------------------------------------
 
 We checks that abort properly clean the repository so the same histedit can be
 attempted later.
 
   $ cp -R base abort
   $ cd abort
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF
   > pick b449568bf7fc 13 f
   > pick 7395e1ff83bd 15 h
   > pick 6b70183d2492 14 g
   > pick b605fb7503f2 16 i
   > roll 3a6c53ee7f3d 17 j
   > edit ee118ab9fa44 18 k
   > EOF
   Editing (ee118ab9fa44), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
 
 #if abortcommand
 when in dry-run mode
   $ hg abort --dry-run
   histedit in progress, will be aborted
 #endif
 
   $ hg abort
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/abort/.hg/strip-backup/4dc06258baa6-dff4ef05-backup.hg
 
   $ hg log -G
   @  18:ee118ab9fa44 (secret) k
   |
   o  17:3a6c53ee7f3d (secret) j
   |
   o  16:b605fb7503f2 (secret) i
   |
   o  15:7395e1ff83bd (draft) h
   |
   o  14:6b70183d2492 (draft) g
   |
   o  13:b449568bf7fc (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ hg histedit -r 'b449568bf7fc' --commands - << EOF --config experimental.evolution.track-operation=1
   > pick b449568bf7fc 13 f
   > pick 7395e1ff83bd 15 h
   > pick 6b70183d2492 14 g
   > pick b605fb7503f2 16 i
   > pick 3a6c53ee7f3d 17 j
   > edit ee118ab9fa44 18 k
   > EOF
   Editing (ee118ab9fa44), you may commit or record as needed now.
   (hg histedit --continue to resume)
   [240]
   $ hg histedit --continue --config experimental.evolution.track-operation=1
   $ hg log -G
   @  23:175d6b286a22 (secret) k
   |
   o  22:44ca09d59ae4 (secret) j
   |
   o  21:31747692a644 (secret) i
   |
   o  20:9985cd4f21fa (draft) g
   |
   o  19:4dc06258baa6 (draft) h
   |
   o  13:b449568bf7fc (draft) f
   |
   o  12:40db8afa467b (public) c
   |
   o  0:cb9a9f314b8b (public) a
   
   $ hg debugobsolete --rev .
   ee118ab9fa44ebb86be85996548b5517a39e5093 175d6b286a224c23f192e79a581ce83131a53fa2 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '4', 'operation': 'histedit', 'user': 'test'}

tests/test-rebase-collapse.t

@@ -1,776 +1,776 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > mq=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > tglogp = log -G --template "{rev}: {node|short} {phase} '{desc}' {branches}\n"
   > EOF
 
 Highest phase of source commits is used:
 
   $ hg init phase
   $ cd phase
   $ hg debugdrawdag << 'EOF'
   >   D
   >   |
   > F C
   > | |
   > E B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
 
   $ cat > $TESTTMP/editor.sh <<EOF
   > echo "==== before editing"
   > cat \$1
   > echo "===="
   > echo "edited manually" >> \$1
   > EOF
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg rebase --collapse --keepbranches -e --source B --dest F
   rebasing 1:112478962961 B "B"
   rebasing 3:26805aba1e60 C "C"
   rebasing 5:f585351a92f8 D tip "D"
   ==== before editing
   Collapsed revision
   * B
   * C
   * D
   
   
   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 B
   HG: added C
   HG: added D
   ====
   saved backup bundle to $TESTTMP/phase/.hg/strip-backup/112478962961-cb2a9b47-rebase.hg
 
   $ hg tglogp
   o  3: 92fa5f5fe108 secret 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |
   |
   |  edited manually'
   o  2: 64a8289d2492 draft 'F'
   |
   o  1: 7fb047a69f22 draft 'E'
   |
   o  0: 426bada5c675 draft 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   E
   F
 
   $ cd ..
 
 
 Merge gets linearized:
 
   $ hg init linearized-merge
   $ cd linearized-merge
 
   $ hg debugdrawdag << 'EOF'
   > F D
   > |/|
   > C B
   > |/
   > A
   > EOF
 
   $ hg phase --force --secret D
   $ hg rebase --source B --collapse --dest F
   rebasing 1:112478962961 B "B"
   rebasing 3:4e4f9194f9f1 D "D"
   saved backup bundle to $TESTTMP/linearized-merge/.hg/strip-backup/112478962961-e389075b-rebase.hg
 
   $ hg tglog
   o  3: 5bdc08b7da2b 'Collapsed revision
   |  * B
   |  * D'
   o  2: afc707c82df0 'F'
   |
   o  1: dc0947a82db8 'C'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   F
 
   $ cd ..
 
 Custom message:
 
   $ hg init message
   $ cd message
 
   $ hg debugdrawdag << 'EOF'
   >   C
   >   |
   > D B
   > |/
   > A
   > EOF
 
 
   $ hg rebase --base B -m 'custom message'
   abort: message can only be specified with collapse
   [255]
 
   $ cat > $TESTTMP/checkeditform.sh <<EOF
   > env | grep HGEDITFORM
   > true
   > EOF
   $ HGEDITOR="sh $TESTTMP/checkeditform.sh" hg rebase --source B --collapse -m 'custom message' -e --dest D
   rebasing 1:112478962961 B "B"
   rebasing 3:26805aba1e60 C tip "C"
   HGEDITFORM=rebase.collapse
   saved backup bundle to $TESTTMP/message/.hg/strip-backup/112478962961-f4131707-rebase.hg
 
   $ hg tglog
   o  2: 2f197b9a08f3 'custom message'
   |
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
 
   $ cd ..
 
 Rebase and collapse - more than one external (fail):
 
   $ hg init multiple-external-parents
   $ cd multiple-external-parents
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s C --dest H --collapse
   abort: unable to collapse on top of 3, there is more than one external parent: 1, 6
   [255]
 
 Rebase and collapse - E onto H:
 
   $ hg rebase -s E --dest H --collapse # root (E) is not a merge
   rebasing 5:49cb92066bfd E "E"
   rebasing 6:11abe3fb10b8 F "F"
   rebasing 7:64e264db77f0 G tip "G"
   saved backup bundle to $TESTTMP/multiple-external-parents/.hg/strip-backup/49cb92066bfd-ee8a8a79-rebase.hg
 
   $ hg tglog
   o    5: 8b2315790719 'Collapsed revision
   |\   * E
   | |  * F
   | |  * G'
   | o    4: 4e4f9194f9f1 'D'
   | |\
   o | |  3: 575c4b5ec114 'H'
   | | |
   +---o  2: dc0947a82db8 'C'
   | |
   | o  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   C
   E
   F
   H
 
   $ cd ..
 
 
 
 
 Test that branchheads cache is updated correctly when doing a strip in which
 the parent of the ancestor node to be stripped does not become a head and also,
 the parent of a node that is a child of the node stripped becomes a head (node
 3). The code is now much simpler and we could just test a simpler scenario
 We keep it the test this way in case new complexity is injected.
 
 Create repo b:
 
   $ hg init branch-heads
   $ cd branch-heads
 
   $ hg debugdrawdag << 'EOF'
   >   G
   >   |\
   >   | F
   >   | |
   >   D E
   >   |\|
   > H C B
   >  \|/
   >   A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   7:64e264db77f061f16d9132b70c5a58e2461fb630 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   64e264db77f061f16d9132b70c5a58e2461fb630 7
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   64e264db77f061f16d9132b70c5a58e2461fb630 o default
 
   $ hg strip 4
   saved backup bundle to $TESTTMP/branch-heads/.hg/strip-backup/4e4f9194f9f1-5ec4b5e6-backup.hg
 
   $ cat $TESTTMP/branch-heads/.hg/cache/branch2-served
   11abe3fb10b8689b560681094b17fe161871d043 5
   dc0947a82db884575bb76ea10ac97b08536bfa03 o default
   575c4b5ec114d64b681d33f8792853568bfb2b2c o default
   11abe3fb10b8689b560681094b17fe161871d043 o default
 
   $ hg heads --template="{rev}:{node} {branch}\n"
   5:11abe3fb10b8689b560681094b17fe161871d043 default
   3:575c4b5ec114d64b681d33f8792853568bfb2b2c default
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default
 
   $ cd ..
 
 
 
 Preserves external parent
 
   $ hg init external-parent
   $ cd external-parent
 
   $ hg debugdrawdag << 'EOF'
   >   H
   >   |\
   >   | G
   >   | |
   >   | F # F/E = F\n
   >   | |
   >   D E # D/D = D\n
   >   |\|
   > I C B
   >  \|/
   >   A
   > EOF
 
   $ hg rebase -s F --dest I --collapse # root (F) is not a merge
   rebasing 6:c82b08f646f1 F "F"
   file 'E' was deleted in local [dest] but was modified in other [source].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
 
   $ echo F > E
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase -c
   rebasing 6:c82b08f646f1 F "F"
   rebasing 7:a6db7fa104e1 G "G"
   rebasing 8:e1d201b72d91 H tip "H"
   saved backup bundle to $TESTTMP/external-parent/.hg/strip-backup/c82b08f646f1-f2721fbf-rebase.hg
 
   $ hg tglog
   o    6: 681daa3e686d 'Collapsed revision
   |\   * F
   | |  * G
   | |  * H'
   | | o  5: 49cb92066bfd 'E'
   | | |
   | o |  4: 09143c0bf13e 'D'
   | |\|
   o | |  3: 08ebfeb61bac 'I'
   | | |
   | o |  2: dc0947a82db8 'C'
   |/ /
   | o  1: 112478962961 'B'
   |/
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   C
   D
   E
   F
   G
   I
 
   $ hg up tip -q
   $ cat E
   F
 
   $ cd ..
 
 Rebasing from multiple bases:
 
   $ hg init multiple-bases
   $ cd multiple-bases
   $ hg debugdrawdag << 'EOF'
   >   C B
   > D |/
   > |/
   > A
   > EOF
   $ hg rebase --collapse -r 'B+C' -d D
   rebasing 1:fc2b737bb2e5 B "B"
   rebasing 2:dc0947a82db8 C "C"
   saved backup bundle to $TESTTMP/multiple-bases/.hg/strip-backup/dc0947a82db8-b0c1a7ea-rebase.hg
   $ hg tglog
   o  2: 2127ae44d291 'Collapsed revision
   |  * B
   |  * C'
   o  1: b18e25de2cf5 'D'
   |
   o  0: 426bada5c675 'A'
   
   $ cd ..
 
 With non-contiguous commits:
 
   $ hg init non-contiguous
   $ cd non-contiguous
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=all
   > EOF
 
   $ hg debugdrawdag << 'EOF'
   > F
   > |
   > E
   > |
   > D
   > |
   > C
   > |
   > B G
   > |/
   > A
   > EOF
 
 BROKEN: should be allowed
   $ hg rebase --collapse -r 'B+D+F' -d G
   abort: unable to collapse on top of 2, there is more than one external parent: 3, 5
   [255]
   $ cd ..
 
 
   $ hg init multiple-external-parents-2
   $ cd multiple-external-parents-2
   $ hg debugdrawdag << 'EOF'
   > D       G
   > |\     /|
   > B C   E F
   >  \|   |/
   >   \ H /
   >    \|/
   >     A
   > EOF
 
   $ hg rebase --collapse -d H -s 'B+F'
   abort: unable to collapse on top of 5, there is more than one external parent: 1, 3
   [255]
   $ cd ..
 
 With internal merge:
 
   $ hg init internal-merge
   $ cd internal-merge
 
   $ hg debugdrawdag << 'EOF'
   >   E
   >   |\
   >   C D
   >   |/
   > F B
   > |/
   > A
   > EOF
 
 
   $ hg rebase -s B --collapse --dest F
   rebasing 1:112478962961 B "B"
   rebasing 3:26805aba1e60 C "C"
   rebasing 4:be0ef73c17ad D "D"
   rebasing 5:02c4367d6973 E tip "E"
   saved backup bundle to $TESTTMP/internal-merge/.hg/strip-backup/112478962961-1dfb057b-rebase.hg
 
   $ hg tglog
   o  2: c0512a1797b0 'Collapsed revision
   |  * B
   |  * C
   |  * D
   |  * E'
   o  1: 8908a377a434 'F'
   |
   o  0: 426bada5c675 'A'
   
   $ hg manifest --rev tip
   A
   B
   C
   D
   F
   $ cd ..
 
 Interactions between collapse and keepbranches
   $ hg init e
   $ cd e
   $ echo 'a' > a
   $ hg ci -Am 'A'
   adding a
 
   $ hg branch 'one'
   marked working directory as branch one
   (branches are permanent and global, did you want a bookmark?)
   $ echo 'b' > b
   $ hg ci -Am 'B'
   adding b
 
   $ hg branch 'two'
   marked working directory as branch two
   $ echo 'c' > c
   $ hg ci -Am 'C'
   adding c
 
   $ hg up -q 0
   $ echo 'd' > d
   $ hg ci -Am 'D'
   adding d
 
   $ hg tglog
   @  3: 41acb9dca9eb 'D'
   |
   | o  2: 8ac4a08debf1 'C' two
   | |
   | o  1: 1ba175478953 'B' one
   |/
   o  0: 1994f17a630e 'A'
   
   $ hg rebase --keepbranches --collapse -s 1 -d 3
   abort: cannot collapse multiple named branches
   [255]
 
   $ cd ..
 
 Rebase, collapse and copies
 
   $ hg init copies
   $ cd copies
   $ hg unbundle "$TESTDIR/bundles/renames.hg"
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 11 changes to 7 files (+1 heads)
   new changesets f447d5abf5ea:338e84e2e558 (4 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up -q tip
   $ hg tglog
   @  3: 338e84e2e558 'move2'
   |
   o  2: 6e7340ee38c0 'move1'
   |
   | o  1: 1352765a01d4 'change'
   |/
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -d 1
   rebasing 2:6e7340ee38c0 "move1"
   merging a and d to d
   merging b and e to e
   merging c and f to f
   rebasing 3:338e84e2e558 tip "move2"
   merging f and c to c
   merging e and g to g
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/6e7340ee38c0-ef8ef003-rebase.hg
   $ hg st
   $ hg st --copies --change tip
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ hg log -r . --template "{file_copies}\n"
   d (a)g (b)
 
 Test collapsing a middle revision in-place
 
   $ hg tglog
   @  2: 64b456429f67 'Collapsed revision
   |  * move1
   |  * move2'
   o  1: 1352765a01d4 'change'
   |
   o  0: f447d5abf5ea 'add'
   
   $ hg rebase --collapse -r 1 -d 0
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
-  [255]
+  [10]
 
 Test collapsing in place
 
   $ hg rebase --collapse -b . -d 0
   rebasing 1:1352765a01d4 "change"
   rebasing 2:64b456429f67 tip "Collapsed revision"
   saved backup bundle to $TESTTMP/copies/.hg/strip-backup/1352765a01d4-45a352ea-rebase.hg
   $ hg st --change tip --copies
   M a
   M c
   A d
     a
   A g
     b
   R b
   $ hg up tip -q
   $ cat a
   a
   a
   $ cat c
   c
   c
   $ cat d
   a
   a
   $ cat g
   b
   b
   $ cd ..
 
 
 Test stripping a revision with another child
 
   $ hg init f
   $ cd f
 
   $ hg debugdrawdag << 'EOF'
   > C B
   > |/
   > A
   > EOF
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   2:dc0947a82db884575bb76ea10ac97b08536bfa03 default: C
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ hg strip C
   saved backup bundle to $TESTTMP/f/.hg/strip-backup/dc0947a82db8-d21b92a4-backup.hg
 
   $ hg tglog
   o  1: 112478962961 'B'
   |
   o  0: 426bada5c675 'A'
   
 
 
   $ hg heads --template="{rev}:{node} {branch}: {desc}\n"
   1:112478962961147124edd43549aedd1a335e44bf default: B
 
   $ cd ..
 
 Test collapsing changes that add then remove a file
 
   $ hg init collapseaddremove
   $ cd collapseaddremove
 
   $ touch base
   $ hg commit -Am base
   adding base
   $ touch a
   $ hg commit -Am a
   adding a
   $ hg rm a
   $ touch b
   $ hg commit -Am b
   adding b
   $ hg book foo
   $ hg rebase -d 0 -r "1::2" --collapse -m collapsed
   rebasing 1:6d8d9f24eec3 "a"
   rebasing 2:1cc73eca5ecc foo tip "b"
   saved backup bundle to $TESTTMP/collapseaddremove/.hg/strip-backup/6d8d9f24eec3-77d3b6e2-rebase.hg
   $ hg log -G --template "{rev}: '{desc}' {bookmarks}"
   @  1: 'collapsed' foo
   |
   o  0: 'base'
   
   $ hg manifest --rev tip
   b
   base
 
   $ cd ..
 
 Test that rebase --collapse will remember message after
 running into merge conflict and invoking rebase --continue.
 
   $ hg init collapse_remember_message
   $ cd collapse_remember_message
   $ hg debugdrawdag << 'EOF'
   > C B # B/A = B\n
   > |/  # C/A = C\n
   > A
   > EOF
   $ hg rebase --collapse -m "new message" -b B -d C
   rebasing 1:81e5401e4d37 B "B"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
   $ rm A.orig
   $ hg resolve --mark A
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:81e5401e4d37 B "B"
   saved backup bundle to $TESTTMP/collapse_remember_message/.hg/strip-backup/81e5401e4d37-96c3dd30-rebase.hg
   $ hg log
   changeset:   2:17186933e123
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     new message
   
   changeset:   1:043039e9df84
   tag:         C
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     C
   
   changeset:   0:426bada5c675
   tag:         A
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     A
   
   $ cd ..
 
 Test aborted editor on final message
 
   $ HGMERGE=:merge3
   $ export HGMERGE
   $ hg init aborted-editor
   $ cd aborted-editor
   $ hg debugdrawdag << 'EOF'
   > C   # D/A = D\n
   > |   # C/A = C\n
   > B D # B/A = B\n
   > |/  # A/A = A\n
   > A
   > EOF
   $ hg rebase --collapse -t internal:merge3 -s B -d D
   rebasing 1:f899f3910ce7 B "B"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
   $ hg tglog
   o  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   % |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   D
   ||||||| base
   A
   =======
   B
   >>>>>>> source: f899f3910ce7 B - test: B
   $ echo BC > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ hg rebase --continue
   rebasing 1:f899f3910ce7 B "B"
   rebasing 3:63668d570d21 C tip "C"
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see 'hg resolve', then 'hg rebase --continue')
   [240]
   $ hg tglog
   %  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ cat A
   <<<<<<< dest:   82b8abf9c185 D - test: D
   BC
   ||||||| base
   B
   =======
   C
   >>>>>>> source: 63668d570d21 C tip - test: C
   $ echo BD > A
   $ hg resolve -m
   (no more unresolved files)
   continue: hg rebase --continue
   $ HGEDITOR=false hg rebase --continue --config ui.interactive=1
   already rebased 1:f899f3910ce7 B "B" as 82b8abf9c185
   rebasing 3:63668d570d21 C tip "C"
   abort: edit failed: false exited with status 1
   [255]
   $ hg tglog
   o  3: 63668d570d21 'C'
   |
   | @  2: 82b8abf9c185 'D'
   | |
   o |  1: f899f3910ce7 'B'
   |/
   o  0: 4a2df7238c3b 'A'
   
   $ hg rebase --continue
   already rebased 1:f899f3910ce7 B "B" as 82b8abf9c185
   already rebased 3:63668d570d21 C tip "C" as 82b8abf9c185
   saved backup bundle to $TESTTMP/aborted-editor/.hg/strip-backup/f899f3910ce7-7cab5e15-rebase.hg

tests/test-rebase-scenario-global.t

@@ -1,985 +1,985 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > drawdag=$TESTDIR/drawdag.py
   > 
   > [phases]
   > publish=False
   > 
   > [alias]
   > tglog = log -G --template "{rev}: {node|short} '{desc}' {branches}\n"
   > EOF
 
 
   $ hg init a
   $ cd a
   $ hg unbundle "$TESTDIR/bundles/rebase.hg"
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 7 changes to 7 files (+2 heads)
   new changesets cd010b8cd998:02de42196ebe (8 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg up tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 
 Rebasing
 D onto H - simple rebase:
 (this also tests that editor is invoked if '--edit' is specified, and that we
 can abort or warn for colliding untracked files)
 
   $ hg clone -q -u . a a1
   $ cd a1
 
   $ hg tglog
   @  7: 02de42196ebe 'H'
   |
   | o  6: eea13746799a 'G'
   |/|
   o |  5: 24b6387c8c8c 'F'
   | |
   | o  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
 
   $ hg status --rev "3^1" --rev 3
   A D
   $ echo collide > D
   $ HGEDITOR=cat hg rebase -s 3 -d 7 --edit --config merge.checkunknown=warn
   rebasing 3:32af7686d403 "D"
   D: replacing untracked file
   D
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: Nicolas Dumazet <[e-mail]>
   HG: branch 'default'
   HG: added D
   saved backup bundle to $TESTTMP/a1/.hg/strip-backup/32af7686d403-6f7dface-rebase.hg
   $ cat D.orig
   collide
   $ rm D.orig
 
   $ hg tglog
   o  7: 1619f02ff7dd 'D'
   |
   @  6: 02de42196ebe 'H'
   |
   | o  5: eea13746799a 'G'
   |/|
   o |  4: 24b6387c8c8c 'F'
   | |
   | o  3: 9520eea781bc 'E'
   |/
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 D onto F - intermediate point:
 (this also tests that editor is not invoked if '--edit' is not specified, and
 that we can ignore for colliding untracked files)
 
   $ hg clone -q -u . a a2
   $ cd a2
   $ echo collide > D
 
   $ HGEDITOR=cat hg rebase -s 3 -d 5 --config merge.checkunknown=ignore
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a2/.hg/strip-backup/32af7686d403-6f7dface-rebase.hg
   $ cat D.orig
   collide
   $ rm D.orig
 
   $ hg tglog
   o  7: 2107530e74ab 'D'
   |
   | @  6: 02de42196ebe 'H'
   |/
   | o  5: eea13746799a 'G'
   |/|
   o |  4: 24b6387c8c8c 'F'
   | |
   | o  3: 9520eea781bc 'E'
   |/
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 E onto H - skip of G:
 (this also tests that we can overwrite untracked files and don't create backups
 if they have the same contents)
 
   $ hg clone -q -u . a a3
   $ cd a3
   $ hg cat -r 4 E | tee E
   E
 
   $ hg rebase -s 4 -d 7
   rebasing 4:9520eea781bc "E"
   rebasing 6:eea13746799a "G"
   note: not rebasing 6:eea13746799a "G", its destination already has all its changes
   saved backup bundle to $TESTTMP/a3/.hg/strip-backup/9520eea781bc-fcd8edd4-rebase.hg
   $ f E.orig
   E.orig: file not found
 
   $ hg tglog
   o  6: 9f8b8ec77260 'E'
   |
   @  5: 02de42196ebe 'H'
   |
   o  4: 24b6387c8c8c 'F'
   |
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 F onto E - rebase of a branching point (skip G):
 
   $ hg clone -q -u . a a4
   $ cd a4
 
   $ hg rebase -s 5 -d 4
   rebasing 5:24b6387c8c8c "F"
   rebasing 6:eea13746799a "G"
   note: not rebasing 6:eea13746799a "G", its destination already has all its changes
   rebasing 7:02de42196ebe tip "H"
   saved backup bundle to $TESTTMP/a4/.hg/strip-backup/24b6387c8c8c-c3fe765d-rebase.hg
 
   $ hg tglog
   @  6: e9240aeaa6ad 'H'
   |
   o  5: 5d0ccadb6e3e 'F'
   |
   o  4: 9520eea781bc 'E'
   |
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 G onto H - merged revision having a parent in ancestors of target:
 
   $ hg clone -q -u . a a5
   $ cd a5
 
   $ hg rebase -s 6 -d 7
   rebasing 6:eea13746799a "G"
   saved backup bundle to $TESTTMP/a5/.hg/strip-backup/eea13746799a-883828ed-rebase.hg
 
   $ hg tglog
   o    7: 397834907a90 'G'
   |\
   | @  6: 02de42196ebe 'H'
   | |
   | o  5: 24b6387c8c8c 'F'
   | |
   o |  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 F onto B - G maintains E as parent:
 
   $ hg clone -q -u . a a6
   $ cd a6
 
   $ hg rebase -s 5 -d 1
   rebasing 5:24b6387c8c8c "F"
   rebasing 6:eea13746799a "G"
   rebasing 7:02de42196ebe tip "H"
   saved backup bundle to $TESTTMP/a6/.hg/strip-backup/24b6387c8c8c-c3fe765d-rebase.hg
 
   $ hg tglog
   @  7: c87be72f9641 'H'
   |
   | o  6: 17badd73d4f1 'G'
   |/|
   o |  5: 74fb9ed646c4 'F'
   | |
   | o  4: 9520eea781bc 'E'
   | |
   | | o  3: 32af7686d403 'D'
   | | |
   +---o  2: 5fddd98957c8 'C'
   | |
   o |  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
   $ cd ..
 
 
 These will fail (using --source):
 
 G onto F - rebase onto an ancestor:
 
   $ hg clone -q -u . a a7
   $ cd a7
 
   $ hg rebase -s 6 -d 5
   nothing to rebase
   [1]
 
 F onto G - rebase onto a descendant:
 
   $ hg rebase -s 5 -d 6
   abort: source and destination form a cycle
   [255]
 
 G onto B - merge revision with both parents not in ancestors of target:
 
   $ hg rebase -s 6 -d 1
   rebasing 6:eea13746799a "G"
   abort: cannot rebase 6:eea13746799a without moving at least one of its parents
   [255]
   $ hg rebase --abort
   rebase aborted
 
 These will abort gracefully (using --base):
 
 G onto G - rebase onto same changeset:
 
   $ hg rebase -b 6 -d 6
   nothing to rebase - eea13746799a is both "base" and destination
   [1]
 
 G onto F - rebase onto an ancestor:
 
   $ hg rebase -b 6 -d 5
   nothing to rebase
   [1]
 
 F onto G - rebase onto a descendant:
 
   $ hg rebase -b 5 -d 6
   nothing to rebase - "base" 24b6387c8c8c is already an ancestor of destination eea13746799a
   [1]
 
 C onto A - rebase onto an ancestor:
 
   $ hg rebase -d 0 -s 2
   rebasing 2:5fddd98957c8 "C"
   rebasing 3:32af7686d403 "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/5fddd98957c8-f9244fa1-rebase.hg
   $ hg tglog
   o  7: c9659aac0000 'D'
   |
   o  6: e1c4361dd923 'C'
   |
   | @  5: 02de42196ebe 'H'
   | |
   | | o  4: eea13746799a 'G'
   | |/|
   | o |  3: 24b6387c8c8c 'F'
   |/ /
   | o  2: 9520eea781bc 'E'
   |/
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
 
 Check rebasing public changeset
 
   $ hg pull --config phases.publish=True -q -r 6 . # update phase of 6
   $ hg rebase -d 0 -b 6
   abort: cannot rebase public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
   $ hg rebase -d 5 -b 6
   abort: cannot rebase public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
   $ hg rebase -d 5 -r '1 + (6::)'
   abort: cannot rebase public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
 
   $ hg rebase -d 5 -b 6 --keep
   rebasing 6:e1c4361dd923 "C"
   rebasing 7:c9659aac0000 tip "D"
 
 Check rebasing mutable changeset
 Source phase greater or equal to destination phase: new changeset get the phase of source:
   $ hg id -n
   5
   $ hg rebase -s9 -d0
   rebasing 9:2b23e52411f4 tip "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/2b23e52411f4-f942decf-rebase.hg
   $ hg id -n # check we updated back to parent
   5
   $ hg log --template "{phase}\n" -r 9
   draft
   $ hg rebase -s9 -d1
   rebasing 9:2cb10d0cfc6c tip "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/2cb10d0cfc6c-ddb0f256-rebase.hg
   $ hg log --template "{phase}\n" -r 9
   draft
   $ hg phase --force --secret 9
   $ hg rebase -s9 -d0
   rebasing 9:c5b12b67163a tip "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/c5b12b67163a-4e372053-rebase.hg
   $ hg log --template "{phase}\n" -r 9
   secret
   $ hg rebase -s9 -d1
   rebasing 9:2a0524f868ac tip "D"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/2a0524f868ac-cefd8574-rebase.hg
   $ hg log --template "{phase}\n" -r 9
   secret
 Source phase lower than destination phase: new changeset get the phase of destination:
   $ hg rebase -s8 -d9
   rebasing 8:6d4f22462821 "C"
   saved backup bundle to $TESTTMP/a7/.hg/strip-backup/6d4f22462821-3441f70b-rebase.hg
   $ hg log --template "{phase}\n" -r 'rev(9)'
   secret
 
   $ cd ..
 
 Check that temporary bundle doesn't lose phase when not using generaldelta
 
   $ hg --config format.usegeneraldelta=no init issue5678
   $ cd issue5678
   $ grep generaldelta .hg/requires
   [1]
   $ echo a > a
   $ hg ci -Aqm a
   $ echo b > b
   $ hg ci -Aqm b
   $ hg co -q '.^'
   $ echo c > c
   $ hg ci -Aqm c
   $ hg phase --public
   $ hg log -G -T '{rev}:{node|shortest} {phase} {desc}\n'
   @  2:d36c public c
   |
   | o  1:d2ae draft b
   |/
   o  0:cb9a public a
   
   $ hg rebase -s 1 -d 2
   rebasing 1:d2ae7f538514 "b"
   saved backup bundle to $TESTTMP/issue5678/.hg/strip-backup/d2ae7f538514-2953539b-rebase.hg
   $ hg log -G -T '{rev}:{node|shortest} {phase} {desc}\n'
   o  2:c882 draft b
   |
   @  1:d36c public c
   |
   o  0:cb9a public a
   
   $ cd ..
 
 Test for revset
 
 We need a bit different graph
 All destination are B
 
   $ hg init ah
   $ cd ah
   $ hg unbundle "$TESTDIR/bundles/rebase-revset.hg"
   adding changesets
   adding manifests
   adding file changes
   added 9 changesets with 9 changes to 9 files (+2 heads)
   new changesets 9ae2ed22e576:479ddb54a924 (9 drafts)
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ hg tglog
   o  8: 479ddb54a924 'I'
   |
   o  7: 72434a4e60b0 'H'
   |
   o  6: 3d8a618087a7 'G'
   |
   | o  5: 41bfcc75ed73 'F'
   | |
   | o  4: c01897464e7f 'E'
   |/
   o  3: ffd453c31098 'D'
   |
   o  2: c9e50f6cdc55 'C'
   |
   | o  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
   $ cd ..
 
 
 Simple case with keep:
 
 Source on have two descendant heads but ask for one
 
   $ hg clone -q -u . ah ah1
   $ cd ah1
   $ hg rebase -r '2::8' -d 1
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
-  [255]
+  [10]
   $ hg rebase -r '2::8' -d 1 -k
   rebasing 2:c9e50f6cdc55 "C"
   rebasing 3:ffd453c31098 "D"
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   rebasing 8:479ddb54a924 tip "I"
   $ hg tglog
   o  13: 9bf1d9358a90 'I'
   |
   o  12: 274623a778d4 'H'
   |
   o  11: ab8c8617c8e8 'G'
   |
   o  10: c8cbf59f70da 'D'
   |
   o  9: 563e4faab485 'C'
   |
   | o  8: 479ddb54a924 'I'
   | |
   | o  7: 72434a4e60b0 'H'
   | |
   | o  6: 3d8a618087a7 'G'
   | |
   | | o  5: 41bfcc75ed73 'F'
   | | |
   | | o  4: c01897464e7f 'E'
   | |/
   | o  3: ffd453c31098 'D'
   | |
   | o  2: c9e50f6cdc55 'C'
   | |
   o |  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
 
   $ cd ..
 
 Base on have one descendant heads we ask for but common ancestor have two
 
   $ hg clone -q -u . ah ah2
   $ cd ah2
   $ hg rebase -r '3::8' -d 1
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
-  [255]
+  [10]
   $ hg rebase -r '3::8' -d 1 --keep
   rebasing 3:ffd453c31098 "D"
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   rebasing 8:479ddb54a924 tip "I"
   $ hg tglog
   o  12: 9d7da0053b1c 'I'
   |
   o  11: 8fbd00952cbc 'H'
   |
   o  10: 51d434a615ee 'G'
   |
   o  9: a9c125634b0b 'D'
   |
   | o  8: 479ddb54a924 'I'
   | |
   | o  7: 72434a4e60b0 'H'
   | |
   | o  6: 3d8a618087a7 'G'
   | |
   | | o  5: 41bfcc75ed73 'F'
   | | |
   | | o  4: c01897464e7f 'E'
   | |/
   | o  3: ffd453c31098 'D'
   | |
   | o  2: c9e50f6cdc55 'C'
   | |
   o |  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
 
   $ cd ..
 
 rebase subset
 
   $ hg clone -q -u . ah ah3
   $ cd ah3
   $ hg rebase -r '3::7' -d 1
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
-  [255]
+  [10]
   $ hg rebase -r '3::7' -d 1 --keep
   rebasing 3:ffd453c31098 "D"
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   $ hg tglog
   o  11: 8fbd00952cbc 'H'
   |
   o  10: 51d434a615ee 'G'
   |
   o  9: a9c125634b0b 'D'
   |
   | o  8: 479ddb54a924 'I'
   | |
   | o  7: 72434a4e60b0 'H'
   | |
   | o  6: 3d8a618087a7 'G'
   | |
   | | o  5: 41bfcc75ed73 'F'
   | | |
   | | o  4: c01897464e7f 'E'
   | |/
   | o  3: ffd453c31098 'D'
   | |
   | o  2: c9e50f6cdc55 'C'
   | |
   o |  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
 
   $ cd ..
 
 rebase subset with multiple head
 
   $ hg clone -q -u . ah ah4
   $ cd ah4
   $ hg rebase -r '3::(7+5)' -d 1
   abort: cannot rebase changeset with children
   (use --keep to keep original changesets)
-  [255]
+  [10]
   $ hg rebase -r '3::(7+5)' -d 1 --keep
   rebasing 3:ffd453c31098 "D"
   rebasing 4:c01897464e7f "E"
   rebasing 5:41bfcc75ed73 "F"
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   $ hg tglog
   o  13: 8fbd00952cbc 'H'
   |
   o  12: 51d434a615ee 'G'
   |
   | o  11: df23d8bda0b7 'F'
   | |
   | o  10: 47b7889448ff 'E'
   |/
   o  9: a9c125634b0b 'D'
   |
   | o  8: 479ddb54a924 'I'
   | |
   | o  7: 72434a4e60b0 'H'
   | |
   | o  6: 3d8a618087a7 'G'
   | |
   | | o  5: 41bfcc75ed73 'F'
   | | |
   | | o  4: c01897464e7f 'E'
   | |/
   | o  3: ffd453c31098 'D'
   | |
   | o  2: c9e50f6cdc55 'C'
   | |
   o |  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
 
   $ cd ..
 
 More advanced tests
 
 rebase on ancestor with revset
 
   $ hg clone -q -u . ah ah5
   $ cd ah5
   $ hg rebase -r '6::' -d 2
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   rebasing 8:479ddb54a924 tip "I"
   saved backup bundle to $TESTTMP/ah5/.hg/strip-backup/3d8a618087a7-b4f73f31-rebase.hg
   $ hg tglog
   o  8: fcb52e68a694 'I'
   |
   o  7: 77bd65cd7600 'H'
   |
   o  6: 12d0e738fb18 'G'
   |
   | o  5: 41bfcc75ed73 'F'
   | |
   | o  4: c01897464e7f 'E'
   | |
   | o  3: ffd453c31098 'D'
   |/
   o  2: c9e50f6cdc55 'C'
   |
   | o  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
   $ cd ..
 
 
 rebase with multiple root.
 We rebase E and G on B
 We would expect heads are I, F if it was supported
 
   $ hg clone -q -u . ah ah6
   $ cd ah6
   $ hg rebase -r '(4+6)::' -d 1
   rebasing 4:c01897464e7f "E"
   rebasing 5:41bfcc75ed73 "F"
   rebasing 6:3d8a618087a7 "G"
   rebasing 7:72434a4e60b0 "H"
   rebasing 8:479ddb54a924 tip "I"
   saved backup bundle to $TESTTMP/ah6/.hg/strip-backup/3d8a618087a7-aae93a24-rebase.hg
   $ hg tglog
   o  8: 9136df9a87cf 'I'
   |
   o  7: 23e8f30da832 'H'
   |
   o  6: b0efe8534e8b 'G'
   |
   | o  5: 6eb5b496ab79 'F'
   | |
   | o  4: d15eade9b0b1 'E'
   |/
   | o  3: ffd453c31098 'D'
   | |
   | o  2: c9e50f6cdc55 'C'
   | |
   o |  1: 8fd0f7e49f53 'B'
   |/
   o  0: 9ae2ed22e576 'A'
   
   $ cd ..
 
 More complex rebase with multiple roots
 each root have a different common ancestor with the destination and this is a detach
 
 (setup)
 
   $ hg clone -q -u . a a8
   $ cd a8
   $ echo I > I
   $ hg add I
   $ hg commit -m I
   $ hg up 4
   1 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ echo I > J
   $ hg add J
   $ hg commit -m J
   created new head
   $ echo I > K
   $ hg add K
   $ hg commit -m K
   $ hg tglog
   @  10: 23a4ace37988 'K'
   |
   o  9: 1301922eeb0c 'J'
   |
   | o  8: e7ec4e813ba6 'I'
   | |
   | o  7: 02de42196ebe 'H'
   | |
   +---o  6: eea13746799a 'G'
   | |/
   | o  5: 24b6387c8c8c 'F'
   | |
   o |  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
 (actual test)
 
   $ hg rebase --dest 'desc(G)' --rev 'desc(K) + desc(I)'
   rebasing 8:e7ec4e813ba6 "I"
   rebasing 10:23a4ace37988 tip "K"
   saved backup bundle to $TESTTMP/a8/.hg/strip-backup/23a4ace37988-b06984b3-rebase.hg
   $ hg log --rev 'children(desc(G))'
   changeset:   9:adb617877056
   parent:      6:eea13746799a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     I
   
   changeset:   10:882431a34a0e
   tag:         tip
   parent:      6:eea13746799a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     K
   
   $ hg tglog
   @  10: 882431a34a0e 'K'
   |
   | o  9: adb617877056 'I'
   |/
   | o  8: 1301922eeb0c 'J'
   | |
   | | o  7: 02de42196ebe 'H'
   | | |
   o---+  6: eea13746799a 'G'
   |/ /
   | o  5: 24b6387c8c8c 'F'
   | |
   o |  4: 9520eea781bc 'E'
   |/
   | o  3: 32af7686d403 'D'
   | |
   | o  2: 5fddd98957c8 'C'
   | |
   | o  1: 42ccdea3bb16 'B'
   |/
   o  0: cd010b8cd998 'A'
   
 
 Test that rebase is not confused by $CWD disappearing during rebase (issue4121)
 
   $ cd ..
   $ hg init cwd-vanish
   $ cd cwd-vanish
   $ touch initial-file
   $ hg add initial-file
   $ hg commit -m 'initial commit'
   $ touch dest-file
   $ hg add dest-file
   $ hg commit -m 'dest commit'
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ touch other-file
   $ hg add other-file
   $ hg commit -m 'first source commit'
   created new head
   $ mkdir subdir
   $ cd subdir
   $ touch subfile
   $ hg add subfile
   $ hg commit -m 'second source with subdir'
 
   $ hg rebase -b . -d 1 --traceback
   rebasing 2:779a07b1b7a0 "first source commit"
   current directory was removed (rmcwd !)
   (consider changing to repo root: $TESTTMP/cwd-vanish) (rmcwd !)
   rebasing 3:a7d6f3a00bf3 tip "second source with subdir"
   saved backup bundle to $TESTTMP/cwd-vanish/.hg/strip-backup/779a07b1b7a0-853e0073-rebase.hg
 
 Get back to the root of cwd-vanish. Note that even though `cd ..`
 works on most systems, it does not work on FreeBSD 10, so we use an
 absolute path to get back to the repository.
   $ cd $TESTTMP
 
 Test that rebase is done in topo order (issue5370)
 
   $ hg init order
   $ cd order
   $ touch a && hg add a && hg ci -m A
   $ touch b && hg add b && hg ci -m B
   $ touch c && hg add c && hg ci -m C
   $ hg up 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ touch d && hg add d && hg ci -m D
   created new head
   $ hg up 2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ touch e && hg add e && hg ci -m E
   $ hg up 3
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ touch f && hg add f && hg ci -m F
   $ hg up 0
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ touch g && hg add g && hg ci -m G
   created new head
 
   $ hg tglog
   @  6: 124bb27b6f28 'G'
   |
   | o  5: 412b391de760 'F'
   | |
   | | o  4: 82ae8dc7a9b7 'E'
   | | |
   | o |  3: ab709c9f7171 'D'
   | | |
   | | o  2: d84f5cfaaf14 'C'
   | |/
   | o  1: 76035bbd54bd 'B'
   |/
   o  0: 216878401574 'A'
   
 
   $ hg rebase -s 1 -d 6
   rebasing 1:76035bbd54bd "B"
   rebasing 2:d84f5cfaaf14 "C"
   rebasing 4:82ae8dc7a9b7 "E"
   rebasing 3:ab709c9f7171 "D"
   rebasing 5:412b391de760 "F"
   saved backup bundle to $TESTTMP/order/.hg/strip-backup/76035bbd54bd-e341bc99-rebase.hg
 
   $ hg tglog
   o  6: 31884cfb735e 'F'
   |
   o  5: 6d89fa5b0909 'D'
   |
   | o  4: de64d97c697b 'E'
   | |
   | o  3: b18e4d2d0aa1 'C'
   |/
   o  2: 0983daf9ff6a 'B'
   |
   @  1: 124bb27b6f28 'G'
   |
   o  0: 216878401574 'A'
   
 
 Test experimental revset
 ========================
 
   $ cd ../cwd-vanish
 
 Make the repo a bit more interesting
 
   $ hg up 1
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo aaa > aaa
   $ hg add aaa
   $ hg commit -m aaa
   created new head
   $ hg log -G
   @  changeset:   4:5f7bc9025ed2
   |  tag:         tip
   |  parent:      1:58d79cc1cf43
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     aaa
   |
   | o  changeset:   3:1910d5ff34ea
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     second source with subdir
   | |
   | o  changeset:   2:82901330b6ef
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     first source commit
   |
   o  changeset:   1:58d79cc1cf43
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     dest commit
   |
   o  changeset:   0:e94b687f7da3
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial commit
   
 
 Testing from lower head
 
   $ hg up 3
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -r '_destrebase()'
   changeset:   4:5f7bc9025ed2
   tag:         tip
   parent:      1:58d79cc1cf43
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     aaa
   
 
 Testing from upper head
 
   $ hg log -r '_destrebase(4)'
   changeset:   3:1910d5ff34ea
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second source with subdir
   
   $ hg up 4
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg log -r '_destrebase()'
   changeset:   3:1910d5ff34ea
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     second source with subdir
   
 Testing rebase being called inside another transaction
 
   $ cd $TESTTMP
   $ hg init tr-state
   $ cd tr-state
   $ cat > $TESTTMP/wraprebase.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import extensions
   > def _rebase(orig, ui, repo, *args, **kwargs):
   >     with repo.wlock():
   >         with repo.lock():
   >             with repo.transaction(b'wrappedrebase'):
   >                 return orig(ui, repo, *args, **kwargs)
   > def wraprebase(loaded):
   >     assert loaded
   >     rebasemod = extensions.find(b'rebase')
   >     extensions.wrapcommand(rebasemod.cmdtable, b'rebase', _rebase)
   > def extsetup(ui):
   >     extensions.afterloaded(b'rebase', wraprebase)
   > EOF
 
   $ cat >> .hg/hgrc <<EOF
   > [extensions]
   > wraprebase=$TESTTMP/wraprebase.py
   > [experimental]
   > evolution=true
   > EOF
 
   $ hg debugdrawdag <<'EOS'
   > B C
   > |/
   > A
   > EOS
 
   $ hg rebase -s C -d B
   rebasing 2:dc0947a82db8 C tip "C"
 
   $ [ -f .hg/rebasestate ] && echo 'WRONG: rebasestate should not exist'
   [1]

tests/test-split.t

@@ -1,978 +1,978 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
   [255]
 
   $ rm -rf .hg
   $ hg init
 
 Cannot split working directory
 
   $ hg split -r 'wdir()'
   abort: cannot split working directory
   [255]
 
 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
   (see 'hg help phases' for details)
-  [255]
+  [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
   [255]
 
 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
   [255]
   $ 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 with children
-  [255]
+  [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 with children
-  [255]
+  [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
   [255]
 #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

tests/test-unamend.t

@@ -1,421 +1,421 b''
 Test for command `hg unamend` which lives in uncommit extension
 ===============================================================
 
   $ cat >> $HGRCPATH << EOF
   > [alias]
   > glog = log -G -T '{rev}:{node|short}  {desc}'
   > [experimental]
   > evolution = createmarkers, allowunstable
   > [extensions]
   > rebase =
   > amend =
   > uncommit =
   > EOF
 
 Repo Setup
 
   $ hg init repo
   $ cd repo
   $ for ch in a b c d e f g h; do touch $ch; echo "foo" >> $ch; hg ci -Aqm "Added "$ch; done
 
   $ hg glog
   @  7:ec2426147f0e  Added h
   |
   o  6:87d6d6676308  Added g
   |
   o  5:825660c69f0c  Added f
   |
   o  4:aa98ab95a928  Added e
   |
   o  3:62615734edd5  Added d
   |
   o  2:28ad74487de9  Added c
   |
   o  1:29becc82797a  Added b
   |
   o  0:18d04c59bb5d  Added a
   
 Trying to unamend when there was no amend done
 
   $ hg unamend
   abort: changeset must have one predecessor, found 0 predecessors
   [255]
 
 Unamend on clean wdir and tip
 
   $ echo "bar" >> h
   $ hg amend
 
   $ hg exp
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID c9fa1a715c1b7661c0fafb362a9f30bd75878d7d
   # Parent  87d6d66763085b629e6d7ed56778c79827273022
   Added h
   
   diff -r 87d6d6676308 -r c9fa1a715c1b h
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/h	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,2 @@
   +foo
   +bar
 
   $ hg glog --hidden
   @  8:c9fa1a715c1b  Added h
   |
   | x  7:ec2426147f0e  Added h
   |/
   o  6:87d6d6676308  Added g
   |
   o  5:825660c69f0c  Added f
   |
   o  4:aa98ab95a928  Added e
   |
   o  3:62615734edd5  Added d
   |
   o  2:28ad74487de9  Added c
   |
   o  1:29becc82797a  Added b
   |
   o  0:18d04c59bb5d  Added a
   
   $ hg unamend
   $ hg glog --hidden
   @  9:46d02d47eec6  Added h
   |
   | x  8:c9fa1a715c1b  Added h
   |/
   | x  7:ec2426147f0e  Added h
   |/
   o  6:87d6d6676308  Added g
   |
   o  5:825660c69f0c  Added f
   |
   o  4:aa98ab95a928  Added e
   |
   o  3:62615734edd5  Added d
   |
   o  2:28ad74487de9  Added c
   |
   o  1:29becc82797a  Added b
   |
   o  0:18d04c59bb5d  Added a
   
   $ hg diff
   diff -r 46d02d47eec6 h
   --- a/h	Thu Jan 01 00:00:00 1970 +0000
   +++ b/h	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    foo
   +bar
 
   $ hg exp
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 46d02d47eec6ca096b8dcab3f8f5579c40c3dd9a
   # Parent  87d6d66763085b629e6d7ed56778c79827273022
   Added h
   
   diff -r 87d6d6676308 -r 46d02d47eec6 h
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/h	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +foo
 
   $ hg status
   M h
 
   $ hg log -r . -T '{extras % "{extra}\n"}' --config alias.log=log
   branch=default
   unamend_source=c9fa1a715c1b7661c0fafb362a9f30bd75878d7d
 
 Using unamend to undo an unamed (intentional)
 
   $ hg unamend
   $ hg exp
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 850ddfc1bc662997ec6094ada958f01f0cc8070a
   # Parent  87d6d66763085b629e6d7ed56778c79827273022
   Added h
   
   diff -r 87d6d6676308 -r 850ddfc1bc66 h
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/h	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,2 @@
   +foo
   +bar
   $ hg diff
 
 Unamend on a dirty working directory
 
   $ echo "bar" >> a
   $ hg amend
   $ echo "foobar" >> a
   $ echo "bar" >> b
   $ hg status
   M a
   M b
 
   $ hg unamend
 
   $ hg status
   M a
   M b
 
   $ hg diff
   diff -r ec338db45d51 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,3 @@
    foo
   +bar
   +foobar
   diff -r ec338db45d51 b
   --- a/b	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    foo
   +bar
 
 Unamending an added file
 
   $ hg ci -m "Added things to a and b"
   $ echo foo > bar
   $ hg add bar
   $ hg amend
 
   $ hg unamend
   $ hg status
   A bar
 
   $ hg revert --all
   forgetting bar
 
 Unamending a removed file
 
   $ hg remove a
   $ hg amend
 
   $ hg unamend
   $ hg status
   R a
   ? bar
 
   $ hg revert --all
   undeleting a
 
 Unamending an added file with dirty wdir status
 
   $ hg add bar
   $ hg amend
   $ echo bar >> bar
   $ hg status
   M bar
 
   $ hg unamend
   $ hg status
   A bar
   $ hg diff
   diff -r 7f79409af972 bar
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/bar	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,2 @@
   +foo
   +bar
 
   $ hg revert --all
   forgetting bar
   $ rm bar
 
 Unamending in middle of a stack
 
   $ hg glog
   @  19:7f79409af972  Added things to a and b
   |
   o  12:ec338db45d51  Added h
   |
   o  6:87d6d6676308  Added g
   |
   o  5:825660c69f0c  Added f
   |
   o  4:aa98ab95a928  Added e
   |
   o  3:62615734edd5  Added d
   |
   o  2:28ad74487de9  Added c
   |
   o  1:29becc82797a  Added b
   |
   o  0:18d04c59bb5d  Added a
   
   $ hg up 5
   2 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo bar >> f
   $ hg amend
   3 new orphan changesets
   $ hg rebase -s 6 -d . -q
 
   $ hg glog
   o  23:03ddd6fc5af1  Added things to a and b
   |
   o  22:3e7b64ee157b  Added h
   |
   o  21:49635b68477e  Added g
   |
   @  20:93f0e8ffab32  Added f
   |
   o  4:aa98ab95a928  Added e
   |
   o  3:62615734edd5  Added d
   |
   o  2:28ad74487de9  Added c
   |
   o  1:29becc82797a  Added b
   |
   o  0:18d04c59bb5d  Added a
   
 
   $ hg --config experimental.evolution=createmarkers unamend
   abort: cannot unamend changeset with children
-  [255]
+  [10]
 
   $ hg unamend
   3 new orphan changesets
 
 Trying to unamend a public changeset
 
   $ hg up -C 23
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg phase -r . -p
   1 new phase-divergent changesets
   $ hg unamend
   abort: cannot unamend public changesets
   (see 'hg help phases' for details)
-  [255]
+  [10]
 
 Testing whether unamend retains copies or not
 
   $ hg status
 
   $ hg mv a foo
 
   $ hg ci -m "Moved a to foo"
   $ hg exp --git
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID cfef290346fbee5126313d7e1aab51d877679b09
   # Parent  03ddd6fc5af19e028c44a2fd6d790dd22712f231
   Moved a to foo
   
   diff --git a/a b/foo
   rename from a
   rename to foo
 
   $ hg mv b foobar
   $ hg diff --git
   diff --git a/b b/foobar
   rename from b
   rename to foobar
   $ hg amend
 
   $ hg exp --git
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID eca050985275bb271ce3092b54e56ea5c85d29a3
   # Parent  03ddd6fc5af19e028c44a2fd6d790dd22712f231
   Moved a to foo
   
   diff --git a/a b/foo
   rename from a
   rename to foo
   diff --git a/b b/foobar
   rename from b
   rename to foobar
 
   $ hg mv c wat
   $ hg unamend
 
   $ hg verify -v
   repository uses revlog format 1
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   checked 28 changesets with 16 changes to 11 files
 
 Retained copies in new prdecessor commit
 
   $ hg exp --git
   # HG changeset patch
   # User test
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 552e3af4f01f620f88ca27be1f898316235b736a
   # Parent  03ddd6fc5af19e028c44a2fd6d790dd22712f231
   Moved a to foo
   
   diff --git a/a b/foo
   rename from a
   rename to foo
 
 Retained copies in working directoy
 
   $ hg diff --git
   diff --git a/b b/foobar
   rename from b
   rename to foobar
   diff --git a/c b/wat
   rename from c
   rename to wat
   $ hg revert -qa
   $ rm foobar wat
 
 Rename a->b, then amend b->c. After unamend, should look like b->c.
 
   $ hg co -q 0
   $ hg mv a b
   $ hg ci -qm 'move to a b'
   $ hg mv b c
   $ hg amend
   $ hg unamend
   $ hg st --copies --change .
   A b
     a
   R a
   $ hg st --copies
   A c
     b
   R b
   $ hg revert -qa
   $ rm c
 
 Rename a->b, then amend b->c, and working copy change c->d. After unamend, should look like b->d
 
   $ hg co -q 0
   $ hg mv a b
   $ hg ci -qm 'move to a b'
   warning: commit already existed in the repository!
   $ hg mv b c
   $ hg amend
   warning: commit already existed in the repository!
   $ hg mv c d
   $ hg unamend
   $ hg st --copies --change .
   A b
     a
   R a
   $ hg st --copies
   A d
     b
   R b

tests/test-uncommit.t

@@ -1,596 +1,596 b''
 Test uncommit - set up the config
 
   $ cat >> $HGRCPATH <<EOF
   > [experimental]
   > evolution.createmarkers=True
   > evolution.allowunstable=True
   > [extensions]
   > uncommit =
   > drawdag=$TESTDIR/drawdag.py
   > EOF
 
 Build up a repo
 
   $ hg init repo
   $ cd repo
   $ hg bookmark foo
 
 Help for uncommit
 
   $ hg help uncommit
   hg uncommit [OPTION]... [FILE]...
   
   uncommit part or all of a local changeset
   
       This command undoes the effect of a local commit, returning the affected
       files to their uncommitted state. This means that files modified or
       deleted in the changeset will be left unchanged, and so will remain
       modified in the working directory.
   
       If no files are specified, the commit will be pruned, unless --keep is
       given.
   
   (use 'hg help -e uncommit' to show help for the uncommit extension)
   
   options ([+] can be repeated):
   
       --keep                     allow an empty commit after uncommitting
       --allow-dirty-working-copy allow uncommit with outstanding changes
    -n --note TEXT                store a note on uncommit
    -I --include PATTERN [+]      include names matching the given patterns
    -X --exclude PATTERN [+]      exclude names matching the given patterns
    -m --message TEXT             use text as commit message
    -l --logfile FILE             read commit message from file
    -d --date DATE                record the specified date as commit date
    -u --user USER                record the specified user as committer
    -D --currentdate              record the current date as commit date
    -U --currentuser              record the current user as committer
   
   (some details hidden, use --verbose to show complete help)
 
 Uncommit with no commits should fail
 
   $ hg uncommit
   abort: cannot uncommit null changeset
   (no changeset checked out)
-  [255]
+  [10]
 
 Create some commits
 
   $ touch files
   $ hg add files
   $ for i in a ab abc abcd abcde; do echo $i > files; echo $i > file-$i; hg add file-$i; hg commit -m "added file-$i"; done
   $ ls -A
   .hg
   file-a
   file-ab
   file-abc
   file-abcd
   file-abcde
   files
 
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   @  4:6c4fd43ed714e7fcd8adbaa7b16c953c2e985b60 added file-abcde
   |
   o  3:6db330d65db434145c0b59d291853e9a84719b24 added file-abcd
   |
   o  2:abf2df566fc193b3ac34d946e63c1583e4d4732b added file-abc
   |
   o  1:69a232e754b08d568c4899475faf2eb44b857802 added file-ab
   |
   o  0:3004d2d9b50883c1538fc754a3aeb55f1b4084f6 added file-a
   
 Simple uncommit off the top, also moves bookmark
 
   $ hg bookmark
    * foo                       4:6c4fd43ed714
   $ hg uncommit
   $ hg status
   M files
   A file-abcde
   $ hg bookmark
    * foo                       3:6db330d65db4
 
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   x  4:6c4fd43ed714e7fcd8adbaa7b16c953c2e985b60 added file-abcde
   |
   @  3:6db330d65db434145c0b59d291853e9a84719b24 added file-abcd
   |
   o  2:abf2df566fc193b3ac34d946e63c1583e4d4732b added file-abc
   |
   o  1:69a232e754b08d568c4899475faf2eb44b857802 added file-ab
   |
   o  0:3004d2d9b50883c1538fc754a3aeb55f1b4084f6 added file-a
   
 
 Recommit
 
   $ hg commit -m 'new change abcde'
   $ hg status
   $ hg heads -T '{rev}:{node} {desc}'
   5:0c07a3ccda771b25f1cb1edbd02e683723344ef1 new change abcde (no-eol)
 
 Uncommit of non-existent and unchanged files aborts
   $ hg uncommit nothinghere
   abort: cannot uncommit "nothinghere"
   (file does not exist)
   [255]
   $ hg status
   $ hg uncommit file-abc
   abort: cannot uncommit "file-abc"
   (file was not changed in working directory parent)
   [255]
   $ hg status
 
 Try partial uncommit, also moves bookmark
 
   $ hg bookmark
    * foo                       5:0c07a3ccda77
   $ hg uncommit files
   $ hg status
   M files
   $ hg bookmark
    * foo                       6:3727deee06f7
   $ hg heads -T '{rev}:{node} {desc}'
   6:3727deee06f72f5ffa8db792ee299cf39e3e190b new change abcde (no-eol)
   $ hg log -r . -p -T '{rev}:{node} {desc}'
   6:3727deee06f72f5ffa8db792ee299cf39e3e190b new change abcdediff -r 6db330d65db4 -r 3727deee06f7 file-abcde
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/file-abcde	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +abcde
   
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   @  6:3727deee06f72f5ffa8db792ee299cf39e3e190b new change abcde
   |
   | x  5:0c07a3ccda771b25f1cb1edbd02e683723344ef1 new change abcde
   |/
   | x  4:6c4fd43ed714e7fcd8adbaa7b16c953c2e985b60 added file-abcde
   |/
   o  3:6db330d65db434145c0b59d291853e9a84719b24 added file-abcd
   |
   o  2:abf2df566fc193b3ac34d946e63c1583e4d4732b added file-abc
   |
   o  1:69a232e754b08d568c4899475faf2eb44b857802 added file-ab
   |
   o  0:3004d2d9b50883c1538fc754a3aeb55f1b4084f6 added file-a
   
   $ hg commit -m 'update files for abcde'
 
 Uncommit with dirty state
 
   $ echo "foo" >> files
   $ cat files
   abcde
   foo
   $ hg status
   M files
   $ hg uncommit
   abort: uncommitted changes
   (requires --allow-dirty-working-copy to uncommit)
   [20]
   $ hg uncommit files
   abort: uncommitted changes
   (requires --allow-dirty-working-copy to uncommit)
   [20]
   $ cat files
   abcde
   foo
   $ hg commit --amend -m "files abcde + foo"
 
 Testing the 'experimental.uncommitondirtywdir' config
 
   $ echo "bar" >> files
   $ hg uncommit
   abort: uncommitted changes
   (requires --allow-dirty-working-copy to uncommit)
   [20]
   $ hg uncommit --config experimental.uncommitondirtywdir=True
   $ hg commit -m "files abcde + foo"
 
 Uncommit in the middle of a stack, does not move bookmark
 
   $ hg checkout '.^^^'
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (leaving bookmark foo)
   $ hg log -r . -p -T '{rev}:{node} {desc}'
   2:abf2df566fc193b3ac34d946e63c1583e4d4732b added file-abcdiff -r 69a232e754b0 -r abf2df566fc1 file-abc
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/file-abc	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +abc
   diff -r 69a232e754b0 -r abf2df566fc1 files
   --- a/files	Thu Jan 01 00:00:00 1970 +0000
   +++ b/files	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -ab
   +abc
   
   $ hg bookmark
      foo                       9:48e5bd7cd583
   $ hg uncommit
   3 new orphan changesets
   $ hg status
   M files
   A file-abc
   $ hg heads -T '{rev}:{node} {desc}'
   9:48e5bd7cd583eb24164ef8b89185819c84c96ed7 files abcde + foo (no-eol)
   $ hg bookmark
      foo                       9:48e5bd7cd583
   $ hg commit -m 'new abc'
   created new head
 
 Partial uncommit in the middle, does not move bookmark
 
   $ hg checkout '.^'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -r . -p -T '{rev}:{node} {desc}'
   1:69a232e754b08d568c4899475faf2eb44b857802 added file-abdiff -r 3004d2d9b508 -r 69a232e754b0 file-ab
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/file-ab	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +ab
   diff -r 3004d2d9b508 -r 69a232e754b0 files
   --- a/files	Thu Jan 01 00:00:00 1970 +0000
   +++ b/files	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,1 @@
   -a
   +ab
   
   $ hg bookmark
      foo                       9:48e5bd7cd583
   $ hg uncommit file-ab
   1 new orphan changesets
   $ hg status
   A file-ab
 
   $ hg heads -T '{rev}:{node} {desc}\n'
   11:8eb87968f2edb7f27f27fe676316e179de65fff6 added file-ab
   10:5dc89ca4486f8a88716c5797fa9f498d13d7c2e1 new abc
   9:48e5bd7cd583eb24164ef8b89185819c84c96ed7 files abcde + foo
 
   $ hg bookmark
      foo                       9:48e5bd7cd583
   $ hg commit -m 'update ab'
   $ hg status
   $ hg heads -T '{rev}:{node} {desc}\n'
   12:f21039c59242b085491bb58f591afc4ed1c04c09 update ab
   10:5dc89ca4486f8a88716c5797fa9f498d13d7c2e1 new abc
   9:48e5bd7cd583eb24164ef8b89185819c84c96ed7 files abcde + foo
 
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   @  12:f21039c59242b085491bb58f591afc4ed1c04c09 update ab
   |
   o  11:8eb87968f2edb7f27f27fe676316e179de65fff6 added file-ab
   |
   | *  10:5dc89ca4486f8a88716c5797fa9f498d13d7c2e1 new abc
   | |
   | | *  9:48e5bd7cd583eb24164ef8b89185819c84c96ed7 files abcde + foo
   | | |
   | | | x  8:84beeba0ac30e19521c036e4d2dd3a5fa02586ff files abcde + foo
   | | |/
   | | | x  7:0977fa602c2fd7d8427ed4e7ee15ea13b84c9173 update files for abcde
   | | |/
   | | *  6:3727deee06f72f5ffa8db792ee299cf39e3e190b new change abcde
   | | |
   | | | x  5:0c07a3ccda771b25f1cb1edbd02e683723344ef1 new change abcde
   | | |/
   | | | x  4:6c4fd43ed714e7fcd8adbaa7b16c953c2e985b60 added file-abcde
   | | |/
   | | *  3:6db330d65db434145c0b59d291853e9a84719b24 added file-abcd
   | | |
   | | x  2:abf2df566fc193b3ac34d946e63c1583e4d4732b added file-abc
   | |/
   | x  1:69a232e754b08d568c4899475faf2eb44b857802 added file-ab
   |/
   o  0:3004d2d9b50883c1538fc754a3aeb55f1b4084f6 added file-a
   
 Uncommit with draft parent
 
   $ hg uncommit
   $ hg phase -r .
   11: draft
   $ hg commit -m 'update ab again'
 
 Phase is preserved
 
   $ hg uncommit --keep --config phases.new-commit=secret
   note: keeping empty commit
   $ hg phase -r .
   14: draft
   $ hg commit --amend -m 'update ab again'
 
 Uncommit with public parent
 
   $ hg phase -p "::.^"
   $ hg uncommit
   $ hg phase -r .
   11: public
 
 Partial uncommit with public parent
 
   $ echo xyz > xyz
   $ hg add xyz
   $ hg commit -m "update ab and add xyz"
   $ hg uncommit xyz
   $ hg status
   A xyz
   $ hg phase -r .
   17: draft
   $ hg phase -r ".^"
   11: public
 
 Uncommit with --keep or experimental.uncommit.keep leaves an empty changeset
 
   $ cd $TESTTMP
   $ hg init repo1
   $ cd repo1
   $ hg debugdrawdag <<'EOS'
   > Q
   > |
   > P
   > EOS
   $ hg up Q -q
   $ hg uncommit --keep
   note: keeping empty commit
   $ hg log -G -T '{desc} FILES: {files}'
   @  Q FILES:
   |
   | x  Q FILES: Q
   |/
   o  P FILES: P
   
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > uncommit.keep=True
   > EOF
   $ hg ci --amend
   $ hg uncommit
   note: keeping empty commit
   $ hg log -G -T '{desc} FILES: {files}'
   @  Q FILES:
   |
   | x  Q FILES: Q
   |/
   o  P FILES: P
   
   $ hg status
   A Q
   $ hg ci --amend
   $ hg uncommit --no-keep
   $ hg log -G -T '{desc} FILES: {files}'
   x  Q FILES: Q
   |
   @  P FILES: P
   
   $ hg status
   A Q
   $ cd ..
   $ rm -rf repo1
 
 Testing uncommit while merge
 
   $ hg init repo2
   $ cd repo2
 
 Create some history
 
   $ touch a
   $ hg add a
   $ for i in 1 2 3; do echo $i > a; hg commit -m "a $i"; done
   $ hg checkout 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ touch b
   $ hg add b
   $ for i in 1 2 3; do echo $i > b; hg commit -m "b $i"; done
   created new head
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   @  5:2cd56cdde163ded2fbb16ba2f918c96046ab0bf2 b 3
   |
   o  4:c3a0d5bb3b15834ffd2ef9ef603e93ec65cf2037 b 2
   |
   o  3:49bb009ca26078726b8870f1edb29fae8f7618f5 b 1
   |
   | o  2:990982b7384266e691f1bc08ca36177adcd1c8a9 a 3
   | |
   | o  1:24d38e3cf160c7b6f5ffe82179332229886a6d34 a 2
   |/
   o  0:ea4e33293d4d274a2ba73150733c2612231f398c a 1
   
 
 Add and expect uncommit to fail on both merge working dir and merge changeset
 
   $ hg merge 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
   $ hg uncommit
   abort: outstanding uncommitted merge
   (requires --allow-dirty-working-copy to uncommit)
   [20]
 
   $ hg uncommit --config experimental.uncommitondirtywdir=True
   abort: cannot uncommit while merging
-  [255]
+  [20]
 
   $ hg status
   M a
   $ hg commit -m 'merge a and b'
 
   $ hg uncommit
   abort: cannot uncommit merge changeset
   [255]
 
   $ hg status
   $ hg log -G -T '{rev}:{node} {desc}' --hidden
   @    6:c03b9c37bc67bf504d4912061cfb527b47a63c6e merge a and b
   |\
   | o  5:2cd56cdde163ded2fbb16ba2f918c96046ab0bf2 b 3
   | |
   | o  4:c3a0d5bb3b15834ffd2ef9ef603e93ec65cf2037 b 2
   | |
   | o  3:49bb009ca26078726b8870f1edb29fae8f7618f5 b 1
   | |
   o |  2:990982b7384266e691f1bc08ca36177adcd1c8a9 a 3
   | |
   o |  1:24d38e3cf160c7b6f5ffe82179332229886a6d34 a 2
   |/
   o  0:ea4e33293d4d274a2ba73150733c2612231f398c a 1
   
 
 Rename a->b, then remove b in working copy. Result should remove a.
 
   $ hg co -q 0
   $ hg mv a b
   $ hg ci -qm 'move a to b'
   $ hg rm b
   $ hg uncommit --config experimental.uncommitondirtywdir=True
   $ hg st --copies
   R a
   $ hg revert a
 
 Rename a->b, then rename b->c in working copy. Result should rename a->c.
 
   $ hg co -q 0
   $ hg mv a b
   $ hg ci -qm 'move a to b'
   $ hg mv b c
   $ hg uncommit --config experimental.uncommitondirtywdir=True
   $ hg st --copies
   A c
     a
   R a
   $ hg revert a
   $ hg forget c
   $ rm c
 
 Copy a->b1 and a->b2, then rename b1->c in working copy. Result should copy a->b2 and a->c.
 
   $ hg co -q 0
   $ hg cp a b1
   $ hg cp a b2
   $ hg ci -qm 'move a to b1 and b2'
   $ hg mv b1 c
   $ hg uncommit --config experimental.uncommitondirtywdir=True
   $ hg st --copies
   A b2
     a
   A c
     a
   $ cd ..
 
 --allow-dirty-working-copy should also work on a dirty PATH
 
   $ hg init issue5977
   $ cd issue5977
   $ echo 'super critical info!' > a
   $ hg ci -Am 'add a'
   adding a
   $ echo 'foo' > b
   $ hg add b
   $ hg status
   A b
   $ hg uncommit a
   note: keeping empty commit
   $ cat a
   super critical info!
   $ hg log
   changeset:   1:656ba143d384
   tag:         tip
   parent:      -1:000000000000
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a
   
   $ hg ci -Am 'add b'
   $ echo 'foo bar' > b
   $ hg uncommit b
   abort: uncommitted changes
   (requires --allow-dirty-working-copy to uncommit)
   [20]
   $ hg uncommit --allow-dirty-working-copy b
   $ hg log
   changeset:   3:30fa958635b2
   tag:         tip
   parent:      1:656ba143d384
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add b
   
   changeset:   1:656ba143d384
   parent:      -1:000000000000
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add a
   
 Removes can be uncommitted
 
   $ hg ci -m 'modified b'
   $ hg rm b
   $ hg ci -m 'remove b'
   $ hg uncommit b
   note: keeping empty commit
   $ hg status
   R b
 
 Uncommitting a directory won't run afoul of the checks that an explicit file
 can be uncommitted.
 
   $ mkdir dir
   $ echo 1 > dir/file.txt
   $ hg ci -Aqm 'add file in directory'
   $ hg uncommit dir -m 'uncommit with message' -u 'different user' \
   >                 -d 'Jun 30 12:12:12 1980 +0000'
   $ hg status
   A dir/file.txt
   $ hg log -r .
   changeset:   8:b4dd26dc42e0
   tag:         tip
   parent:      6:2278a4c24330
   user:        different user
   date:        Mon Jun 30 12:12:12 1980 +0000
   summary:     uncommit with message
   
 Bad option combinations
 
   $ hg rollback -q --config ui.rollback=True
   $ hg uncommit -U --user 'user'
   abort: cannot specify both --user and --currentuser
   [10]
   $ hg uncommit -D --date today
   abort: cannot specify both --date and --currentdate
   [10]
 
 `uncommit <dir>` and `cd <dir> && uncommit .` behave the same...
 
   $ echo 2 > dir/file2.txt
   $ hg ci -Aqm 'add file2 in directory'
   $ hg uncommit dir
   note: keeping empty commit
   $ hg status
   A dir/file2.txt
 
   $ hg rollback -q --config ui.rollback=True
   $ cd dir
   $ hg uncommit . -n 'this is a note'
   note: keeping empty commit
   $ hg status
   A dir/file2.txt
   $ cd ..
 
 ... and errors out the same way when nothing can be uncommitted
 
   $ hg rollback -q --config ui.rollback=True
   $ mkdir emptydir
   $ hg uncommit emptydir
   abort: cannot uncommit "emptydir"
   (file was untracked in working directory parent)
   [255]
 
   $ cd emptydir
   $ hg uncommit .
   abort: cannot uncommit "emptydir"
   (file was untracked in working directory parent)
   [255]
   $ hg status
   $ cd ..