tests: move non-collapse test out of test-rebase-collapse

The test case was added in 76630fbbf4fa (test-rebase-collapse: Add
test for rebase regression introduced in 12309c09d19a, 2012-01-23). I
think `hg rebase --collapse` was involved in either the regression or
in the fix that caused the regression, but the test that was added
doesn't use `--collapse`, so it doesn't seem to belong in
test-rebase-collapse.t. The test case is about copies, so I moved it
to test-rebase-rename.t.

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

tests/test-rebase-collapse.t

@@ -1,831 +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" (D tip)
   ==== 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" (C tip)
   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 I --collapse # root (E) is not a merge
   abort: unknown revision 'I'!
   [255]
 
   $ hg tglog
   o    7: 64e264db77f0 'G'
   |\
   | o  6: 11abe3fb10b8 'F'
   | |
   | o  5: 49cb92066bfd 'E'
   | |
   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
   B
   C
   E
   F
 
   $ 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)
   [1]
 
   $ 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" (H tip)
   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" (E tip)
   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]
 
-  $ repeatchange() {
-  >   hg checkout $1
-  >   hg cp d z
-  >   echo blah >> z
-  >   hg commit -Am "$2" --user "$3"
-  > }
-  $ repeatchange 3 "E" "user1"
-  0 files updated, 0 files merged, 0 files removed, 0 files unresolved
-  $ repeatchange 3 "E" "user2"
-  0 files updated, 0 files merged, 1 files removed, 0 files unresolved
-  created new head
-  $ hg tglog
-  @  5: fbfb97b1089a 'E'
-  |
-  | o  4: f338eb3c2c7c 'E'
-  |/
-  o  3: 41acb9dca9eb 'D'
-  |
-  | o  2: 8ac4a08debf1 'C' two
-  | |
-  | o  1: 1ba175478953 'B' one
-  |/
-  o  0: 1994f17a630e 'A'
-  
-  $ hg rebase -s 5 -d 4
-  rebasing 5:fbfb97b1089a "E" (tip)
-  note: not rebasing 5:fbfb97b1089a "E" (tip), its destination already has all its changes
-  saved backup bundle to $TESTTMP/e/.hg/strip-backup/fbfb97b1089a-553e1d85-rebase.hg
-  $ hg tglog
-  @  4: f338eb3c2c7c 'E'
-  |
-  o  3: 41acb9dca9eb 'D'
-  |
-  | o  2: 8ac4a08debf1 'C' two
-  | |
-  | o  1: 1ba175478953 'B' one
-  |/
-  o  0: 1994f17a630e 'A'
-  
-  $ hg export tip
-  # HG changeset patch
-  # User user1
-  # Date 0 0
-  #      Thu Jan 01 00:00:00 1970 +0000
-  # Node ID f338eb3c2c7cc5b5915676a2376ba7ac558c5213
-  # Parent  41acb9dca9eb976e84cd21fcb756b4afa5a35c09
-  E
-  
-  diff -r 41acb9dca9eb -r f338eb3c2c7c z
-  --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
-  +++ b/z	Thu Jan 01 00:00:00 1970 +0000
-  @@ -0,0 +1,2 @@
-  +d
-  +blah
-
   $ 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 "move2" (tip)
   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]
 
 Test collapsing in place
 
   $ hg rebase --collapse -b . -d 0
   rebasing 1:1352765a01d4 "change"
   rebasing 2:64b456429f67 "Collapsed revision" (tip)
   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 "b" (foo tip)
   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)
   [1]
   $ 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)
   [1]
   $ 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" (C tip)
   merging A
   warning: conflicts while merging A! (edit, then use 'hg resolve --mark')
   unresolved conflicts (see hg resolve, then hg rebase --continue)
   [1]
   $ hg 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" (C tip)
   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" (C tip) as 82b8abf9c185
   saved backup bundle to $TESTTMP/aborted-editor/.hg/strip-backup/f899f3910ce7-7cab5e15-rebase.hg

tests/test-rebase-rename.t

@@ -1,332 +1,388 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > rebase=
   > 
   > [alias]
   > tlog  = log --template "{rev}: {node|short} '{desc}' {branches}\n"
   > tglog = tlog --graph
   > EOF
 
 
   $ hg init a
   $ cd a
 
   $ mkdir d
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > d/b
   $ hg ci -Am B
   adding d/b
 
   $ hg mv d d-renamed
   moving d/b to d-renamed/b
   $ hg ci -m 'rename B'
 
   $ hg up -q -C 1
 
   $ hg mv a a-renamed
   $ echo x > d/x
   $ hg add d/x
 
   $ hg ci -m 'rename A'
   created new head
 
   $ hg tglog
   @  3: 73a3ee40125d 'rename A'
   |
   | o  2: 220d0626d185 'rename B'
   |/
   o  1: 3ab5da9a5c01 'B'
   |
   o  0: 1994f17a630e 'A'
   
 
 Rename is tracked:
 
   $ hg tlog -p --git -r tip
   3: 73a3ee40125d 'rename A' 
   diff --git a/a b/a-renamed
   rename from a
   rename to a-renamed
   diff --git a/d/x b/d/x
   new file mode 100644
   --- /dev/null
   +++ b/d/x
   @@ -0,0 +1,1 @@
   +x
   
 Rebase the revision containing the rename:
 
   $ hg rebase -s 3 -d 2
   rebasing 3:73a3ee40125d "rename A" (tip)
   saved backup bundle to $TESTTMP/a/.hg/strip-backup/73a3ee40125d-1d78ebcf-rebase.hg
 
   $ hg tglog
   @  3: 032a9b75e83b 'rename A'
   |
   o  2: 220d0626d185 'rename B'
   |
   o  1: 3ab5da9a5c01 'B'
   |
   o  0: 1994f17a630e 'A'
   
 
 Rename is not lost:
 
   $ hg tlog -p --git -r tip
   3: 032a9b75e83b 'rename A' 
   diff --git a/a b/a-renamed
   rename from a
   rename to a-renamed
   diff --git a/d-renamed/x b/d-renamed/x
   new file mode 100644
   --- /dev/null
   +++ b/d-renamed/x
   @@ -0,0 +1,1 @@
   +x
   
 
 Rebased revision does not contain information about b (issue3739)
 
   $ hg log -r 3 --debug
   changeset:   3:032a9b75e83bff1dcfb6cbfa4ef50a704bf1b569
   tag:         tip
   phase:       draft
   parent:      2:220d0626d185f372d9d8f69d9c73b0811d7725f7
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:035d66b27a1b06b2d12b46d41a39adb7a200c370
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      a-renamed d-renamed/x
   files-:      a
   extra:       branch=default
   extra:       rebase_source=73a3ee40125d6f0f347082e5831ceccb3f005f8a
   description:
   rename A
   
   
 
+  $ repeatchange() {
+  >   hg checkout $1
+  >   hg cp a z
+  >   echo blah >> z
+  >   hg commit -Am "$2" --user "$3"
+  > }
+  $ repeatchange 1 "E" "user1"
+  2 files updated, 0 files merged, 3 files removed, 0 files unresolved
+  created new head
+  $ repeatchange 1 "E" "user2"
+  0 files updated, 0 files merged, 1 files removed, 0 files unresolved
+  created new head
+  $ hg tglog
+  @  5: af8ad1f97097 'E'
+  |
+  | o  4: 60f545c27784 'E'
+  |/
+  | o  3: 032a9b75e83b 'rename A'
+  | |
+  | o  2: 220d0626d185 'rename B'
+  |/
+  o  1: 3ab5da9a5c01 'B'
+  |
+  o  0: 1994f17a630e 'A'
+  
+  $ hg rebase -s 5 -d 4
+  rebasing 5:af8ad1f97097 "E" (tip)
+  note: not rebasing 5:af8ad1f97097 "E" (tip), its destination already has all its changes
+  saved backup bundle to $TESTTMP/a/.hg/strip-backup/af8ad1f97097-c3e90708-rebase.hg
+  $ hg tglog
+  @  4: 60f545c27784 'E'
+  |
+  | o  3: 032a9b75e83b 'rename A'
+  | |
+  | o  2: 220d0626d185 'rename B'
+  |/
+  o  1: 3ab5da9a5c01 'B'
+  |
+  o  0: 1994f17a630e 'A'
+  
+  $ hg export tip
+  # HG changeset patch
+  # User user1
+  # Date 0 0
+  #      Thu Jan 01 00:00:00 1970 +0000
+  # Node ID 60f545c277846e6bad309919bae3ae106f59cb39
+  # Parent  3ab5da9a5c01faa02c20f2ec4870a4f689c92da6
+  E
+  
+  diff -r 3ab5da9a5c01 -r 60f545c27784 z
+  --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+  +++ b/z	Thu Jan 01 00:00:00 1970 +0000
+  @@ -0,0 +1,2 @@
+  +a
+  +blah
+
   $ cd ..
 
 
   $ hg init b
   $ cd b
 
   $ echo a > a
   $ hg ci -Am A
   adding a
 
   $ echo b > b
   $ hg ci -Am B
   adding b
 
   $ hg cp b b-copied
   $ hg ci -Am 'copy B'
 
   $ hg up -q -C 1
 
   $ hg cp a a-copied
   $ hg ci -m 'copy A'
   created new head
 
   $ hg tglog
   @  3: 0a8162ff18a8 'copy A'
   |
   | o  2: 39e588434882 'copy B'
   |/
   o  1: 6c81ed0049f8 'B'
   |
   o  0: 1994f17a630e 'A'
   
 Copy is tracked:
 
   $ hg tlog -p --git -r tip
   3: 0a8162ff18a8 'copy A' 
   diff --git a/a b/a-copied
   copy from a
   copy to a-copied
   
 Rebase the revision containing the copy:
 
   $ hg rebase -s 3 -d 2
   rebasing 3:0a8162ff18a8 "copy A" (tip)
   saved backup bundle to $TESTTMP/b/.hg/strip-backup/0a8162ff18a8-dd06302a-rebase.hg
 
   $ hg tglog
   @  3: 98f6e6dbf45a 'copy A'
   |
   o  2: 39e588434882 'copy B'
   |
   o  1: 6c81ed0049f8 'B'
   |
   o  0: 1994f17a630e 'A'
   
 
 Copy is not lost:
 
   $ hg tlog -p --git -r tip
   3: 98f6e6dbf45a 'copy A' 
   diff --git a/a b/a-copied
   copy from a
   copy to a-copied
   
 
 Rebased revision does not contain information about b (issue3739)
 
   $ hg log -r 3 --debug
   changeset:   3:98f6e6dbf45ab54079c2237fbd11066a5c41a11d
   tag:         tip
   phase:       draft
   parent:      2:39e588434882ff77d01229d169cdc77f29e8855e
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    3:2232f329d66fffe3930d43479ae624f66322b04d
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files+:      a-copied
   extra:       branch=default
   extra:       rebase_source=0a8162ff18a8900df8df8ef7ac0046955205613e
   description:
   copy A
   
   
 
   $ cd ..
 
 
 Test rebase across repeating renames:
 
   $ hg init repo
 
   $ cd repo
 
   $ echo testing > file1.txt
   $ hg add file1.txt
   $ hg ci -m "Adding file1"
 
   $ hg rename file1.txt file2.txt
   $ hg ci -m "Rename file1 to file2"
 
   $ echo Unrelated change > unrelated.txt
   $ hg add unrelated.txt
   $ hg ci -m "Unrelated change"
 
   $ hg rename file2.txt file1.txt
   $ hg ci -m "Rename file2 back to file1"
 
   $ hg update -r -2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ echo Another unrelated change >> unrelated.txt
   $ hg ci -m "Another unrelated change"
   created new head
 
   $ hg tglog
   @  4: b918d683b091 'Another unrelated change'
   |
   | o  3: 1ac17e43d8aa 'Rename file2 back to file1'
   |/
   o  2: 480101d66d8d 'Unrelated change'
   |
   o  1: be44c61debd2 'Rename file1 to file2'
   |
   o  0: 8ce9a346991d 'Adding file1'
   
 
   $ hg rebase -s 4 -d 3
   rebasing 4:b918d683b091 "Another unrelated change" (tip)
   saved backup bundle to $TESTTMP/repo/.hg/strip-backup/b918d683b091-3024bc57-rebase.hg
 
   $ hg diff --stat -c .
    unrelated.txt |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
 
   $ cd ..
 
 Verify that copies get preserved (issue4192).
   $ hg init copy-gets-preserved
   $ cd copy-gets-preserved
 
   $ echo a > a
   $ hg add a
   $ hg commit --message "File a created"
   $ hg copy a b
   $ echo b > b
   $ hg commit --message "File b created as copy of a and modified"
   $ hg copy b c
   $ echo c > c
   $ hg commit --message "File c created as copy of b and modified"
   $ hg copy c d
   $ echo d > d
   $ hg commit --message "File d created as copy of c and modified"
 
 Note that there are four entries in the log for d
   $ hg tglog --follow d
   @  3: 421b7e82bb85 'File d created as copy of c and modified'
   |
   o  2: 327f772bc074 'File c created as copy of b and modified'
   |
   o  1: 79d255d24ad2 'File b created as copy of a and modified'
   |
   o  0: b220cd6d2326 'File a created'
   
 Update back to before we performed copies, and inject an unrelated change.
   $ hg update 0
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
 
   $ echo unrelated > unrelated
   $ hg add unrelated
   $ hg commit --message "Unrelated file created"
   created new head
   $ hg update 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Rebase the copies on top of the unrelated change.
   $ hg rebase --source 1 --dest 4
   rebasing 1:79d255d24ad2 "File b created as copy of a and modified"
   rebasing 2:327f772bc074 "File c created as copy of b and modified"
   rebasing 3:421b7e82bb85 "File d created as copy of c and modified"
   saved backup bundle to $TESTTMP/copy-gets-preserved/.hg/strip-backup/79d255d24ad2-a2265555-rebase.hg
   $ hg update 4
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 There should still be four entries in the log for d
   $ hg tglog --follow d
   @  4: dbb9ba033561 'File d created as copy of c and modified'
   |
   o  3: af74b229bc02 'File c created as copy of b and modified'
   |
   o  2: 68bf06433839 'File b created as copy of a and modified'
   :
   o  0: b220cd6d2326 'File a created'
   
 Same steps as above, but with --collapse on rebase to make sure the
 copy records collapse correctly.
   $ hg co 1
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ echo more >> unrelated
   $ hg ci -m 'unrelated commit is unrelated'
   created new head
   $ hg rebase -s 2 --dest 5 --collapse
   rebasing 2:68bf06433839 "File b created as copy of a and modified"
   rebasing 3:af74b229bc02 "File c created as copy of b and modified"
   merging b and c to c
   rebasing 4:dbb9ba033561 "File d created as copy of c and modified"
   merging c and d to d
   saved backup bundle to $TESTTMP/copy-gets-preserved/.hg/strip-backup/68bf06433839-dde37595-rebase.hg
   $ hg co tip
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 This should show both revision 3 and 0 since 'd' was transitively a
 copy of 'a'.
 
   $ hg tglog --follow d
   @  3: 5a46b94210e5 'Collapsed revision
   :  * File b created as copy of a and modified
   :  * File c created as copy of b and modified
   :  * File d created as copy of c and modified'
   o  0: b220cd6d2326 'File a created'
   
 
   $ cd ..