$ hg init t

  $ cd t

  $ mkdir a

  $ echo foo > a/a

  $ echo bar > a/b

  $ hg ci -Am "0"

  adding a/a

  adding a/b

  $ hg co -C 0

  0 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ hg mv a b

  moving a/a to b/a

  moving a/b to b/b

  $ hg ci -m "1 mv a/ b/"

  $ hg co -C 0

  2 files updated, 0 files merged, 2 files removed, 0 files unresolved

  $ echo baz > a/c

  $ echo quux > a/d

  $ hg add a/c

  $ hg ci -m "2 add a/c"

  created new head

  $ hg merge --debug 1

    unmatched files in local:

     a/c

    unmatched files in other:

     b/a

     b/b

    all copies found (* = to merge, ! = divergent, % = renamed and deleted):

     on remote side:

      src: 'a/a' -> dst: 'b/a' 

      src: 'a/b' -> dst: 'b/b' 

    checking for directory renames

     discovered dir src: 'a/' -> dst: 'b/'

     pending file src: 'a/c' -> dst: 'b/c'

  resolving manifests

   branchmerge: True, force: False, partial: False

   ancestor: f9b20c0d4c51, local: ce36d17b18fb+, remote: 397f8b00a740

   a/a: other deleted -> r

  removing a/a

   a/b: other deleted -> r

  removing a/b

   b/a: remote created -> g

  getting b/a

   b/b: remote created -> g

  getting b/b

   b/c: remote directory rename - move from a/c -> dm

  moving a/c to b/c

  3 files updated, 0 files merged, 2 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ echo a/* b/*

  a/d b/a b/b b/c

  $ hg st -C

  M b/a

  M b/b

  A b/c

    a/c

  R a/a

  R a/b

  R a/c

  ? a/d

  $ hg ci -m "3 merge 2+1"

  $ hg debugrename b/c

  b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88

  $ hg co -C 1

  0 files updated, 0 files merged, 1 files removed, 0 files unresolved

  $ hg merge --debug 2

    unmatched files in local:

     b/a

     b/b

    unmatched files in other:

     a/c

    all copies found (* = to merge, ! = divergent, % = renamed and deleted):

     on local side:

      src: 'a/a' -> dst: 'b/a' 

      src: 'a/b' -> dst: 'b/b' 

    checking for directory renames

     discovered dir src: 'a/' -> dst: 'b/'

     pending file src: 'a/c' -> dst: 'b/c'

  resolving manifests

   branchmerge: True, force: False, partial: False

   ancestor: f9b20c0d4c51, local: 397f8b00a740+, remote: ce36d17b18fb

  starting 4 threads for background file closing (?)

   b/c: local directory rename - get from a/c -> dg

  getting a/c to b/c

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ echo a/* b/*

  a/d b/a b/b b/c

  $ hg st -C

  A b/c

    a/c

  ? a/d

  $ hg ci -m "4 merge 1+2"

  created new head

  $ hg debugrename b/c

  b/c renamed from a/c:354ae8da6e890359ef49ade27b68bbc361f3ca88

Local directory rename with conflicting file added in remote source directory

and untracked in local target directory.

  $ hg co -qC 1

  $ echo target > b/c

  $ hg merge 2

  b/c: untracked file differs

  abort: untracked files in working directory differ from files in requested revision

  [20]

  $ cat b/c

  target

but it should succeed if the content matches

  $ hg cat -r 2 a/c > b/c

  $ hg merge 2

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ hg st -C

  A b/c

    a/c

  ? a/d

Local directory rename with conflicting file added in remote source directory

and committed in local target directory.

  $ hg co -qC 1

  $ echo target > b/c

  $ hg add b/c

  $ hg commit -qm 'new file in target directory'

  $ hg merge 2

  merging b/c and a/c to b/c

  warning: conflicts while merging b/c! (edit, then use 'hg resolve --mark')

  0 files updated, 0 files merged, 0 files removed, 1 files unresolved

  use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon

  [1]

  $ hg st -A

  M b/c

    a/c

  ? a/d

  ? b/c.orig

  C b/a

  C b/b

  $ cat b/c

  <<<<<<< working copy: f1c50ca4f127 - test: new file in target directory

  target

  =======

  baz

  >>>>>>> merge rev:    ce36d17b18fb - test: 2 add a/c

  $ rm b/c.orig

Remote directory rename with conflicting file added in remote target directory

and committed in local source directory.

  $ hg co -qC 2

  $ hg st -A

  ? a/d

  C a/a

  C a/b

  C a/c

  $ hg merge 5

  merging a/c and b/c to b/c

  warning: conflicts while merging b/c! (edit, then use 'hg resolve --mark')

  2 files updated, 0 files merged, 2 files removed, 1 files unresolved

  use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon

  [1]

  $ hg st -A

  M b/a

  M b/b

  M b/c

    a/c

  R a/a

  R a/b

  R a/c

  ? a/d

  ? b/c.orig

  $ cat b/c

  <<<<<<< working copy: ce36d17b18fb - test: 2 add a/c

  baz

  =======

  target

  >>>>>>> merge rev:    f1c50ca4f127 - test: new file in target directory

Second scenario with two repos:

  $ cd ..

  $ hg init r1

  $ cd r1

  $ mkdir a

  $ echo foo > a/f

  $ hg add a

  adding a/f

  $ hg ci -m "a/f == foo"

  $ cd ..

  $ hg clone r1 r2

  updating to branch default

  1 files updated, 0 files merged, 0 files removed, 0 files unresolved

  $ cd r2

  $ hg mv a b

  moving a/f to b/f

  $ echo foo1 > b/f

  $ hg ci -m" a -> b, b/f == foo1"

  $ cd ..

  $ cd r1

  $ mkdir a/aa

  $ echo bar > a/aa/g

  $ hg add a/aa

  adding a/aa/g

  $ hg ci -m "a/aa/g"

  $ hg pull ../r2

  pulling from ../r2

  searching for changes

  adding changesets

  adding manifests

  adding file changes

  added 1 changesets with 1 changes to 1 files (+1 heads)

  new changesets 7d51ed18da25

  1 local changesets published

  (run 'hg heads' to see heads, 'hg merge' to merge)

  $ hg merge

  2 files updated, 0 files merged, 1 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ hg st -C

  M b/f

  A b/aa/g

    a/aa/g

  R a/aa/g

  R a/f

  $ cd ..

Test renames to separate directories

  $ hg init a

  $ cd a

  $ mkdir a

  $ touch a/s

  $ touch a/t

  $ hg ci -Am0

  adding a/s

  adding a/t

Add more files

  $ touch a/s2

  $ touch a/t2

  $ hg ci -Am1

  adding a/s2

  adding a/t2

Do moves on a branch

  $ hg up 0

  0 files updated, 0 files merged, 2 files removed, 0 files unresolved

  $ mkdir s

  $ mkdir t

  $ hg mv a/s s

  $ hg mv a/t t

  $ hg ci -Am2

  created new head

  $ hg st --copies --change .

  A s/s

    a/s

  A t/t

    a/t

  R a/s

  R a/t

Merge shouldn't move s2, t2

  $ hg merge

  2 files updated, 0 files merged, 0 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ hg st --copies

  M a/s2

  M a/t2

Try the merge in the other direction. It may or may not be appropriate for

status to list copies here.

  $ hg up -C 1

  4 files updated, 0 files merged, 2 files removed, 0 files unresolved

  $ hg merge

  2 files updated, 0 files merged, 2 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ hg st --copies

  M s/s

  M t/t

  R a/s

  R a/t

  $ cd ..

Test that files are moved to a new directory based on the path prefix that

matches the most. dir1/ below gets renamed to dir2/, and dir1/subdir1/ gets

renamed to dir2/subdir2/. We want dir1/subdir1/newfile to move to

dir2/subdir2/ (not to dir2/subdir1/ as we would infer based on just the rename

of dir1/ to dir2/).

  $ hg init nested-renames

  $ cd nested-renames

  $ mkdir dir1

  $ echo a > dir1/file1

  $ echo b > dir1/file2

  $ mkdir dir1/subdir1

  $ echo c > dir1/subdir1/file3

  $ echo d > dir1/subdir1/file4

  $ hg ci -Aqm initial

  $ hg mv dir1 dir2

  moving dir1/file1 to dir2/file1

  moving dir1/file2 to dir2/file2

  moving dir1/subdir1/file3 to dir2/subdir1/file3

  moving dir1/subdir1/file4 to dir2/subdir1/file4

  $ hg mv dir2/subdir1 dir2/subdir2

  moving dir2/subdir1/file3 to dir2/subdir2/file3

  moving dir2/subdir1/file4 to dir2/subdir2/file4

  $ hg ci -m 'move dir1/ to dir2/ and dir1/subdir1/ to dir2/subdir2/'

  $ hg co 0

  4 files updated, 0 files merged, 4 files removed, 0 files unresolved

  $ echo e > dir1/subdir1/file5

  $ hg ci -Aqm 'add file in dir1/subdir1/'

  $ hg merge 1

  5 files updated, 0 files merged, 4 files removed, 0 files unresolved

  (branch merge, don't forget to commit)

  $ hg files

  dir2/file1

  dir2/file2

  dir2/subdir2/file3

  dir2/subdir2/file4

  dir2/subdir2/file5

  $ cd ..