sidedatacopies: introduce a sidedata testcase for test-copies-unrelated.t

For now it is equivalent to the filelog case, but introducing this early helps
make the comings changesets clearer.

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

tests/test-copies-unrelated.t

@@ -1,389 +1,396 b''
-#testcases filelog compatibility changeset
+#testcases filelog compatibility changeset sidedata
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > rebase=
   > [alias]
   > l = log -G -T '{rev} {desc}\n{files}\n'
   > EOF
 
 #if compatibility
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > copies.read-from = compatibility
   > EOF
 #endif
 
 #if changeset
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > copies.read-from = changeset-only
   > copies.write-to = changeset-only
   > EOF
 #endif
 
+#if sidedata
+  $ cat >> $HGRCPATH << EOF
+  > [format]
+  > exp-use-copies-side-data-changeset = yes
+  > EOF
+#endif
+
   $ REPONUM=0
   $ newrepo() {
   >     cd $TESTTMP
   >     REPONUM=`expr $REPONUM + 1`
   >     hg init repo-$REPONUM
   >     cd repo-$REPONUM
   > }
 
 Copy a file, then delete destination, then copy again. This does not create a new filelog entry.
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ hg cp x y
   $ hg ci -qm 'copy x to y'
   $ hg rm y
   $ hg ci -m 'remove y'
   $ hg cp -f x y
   $ hg ci -m 'copy x onto y (again)'
   $ hg l
   @  4 copy x onto y (again)
   |  y
   o  3 remove y
   |  y
   o  2 copy x to y
   |  y
   | o  1 modify x
   |/   x
   o  0 add x
      x
   $ hg debugp1copies -r 4
   x -> y
   $ hg debugpathcopies 0 4
   x -> y
   $ hg graft -r 1
   grafting 1:* "modify x" (glob)
   merging y and x to y
   $ hg co -qC 1
   $ hg graft -r 4
   grafting 4:* "copy x onto y (again)" (glob)
   merging x and y to y
 
 Copy x to y, then remove y, then add back y. With copy metadata in the
 changeset, this could easily end up reporting y as copied from x (if we don't
 unmark it as a copy when it's removed). Despite x and y not being related, we
 want grafts to propagate across the rename.
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ hg mv x y
   $ hg ci -qm 'rename x to y'
   $ hg rm y
   $ hg ci -qm 'remove y'
   $ echo x > y
   $ hg ci -Aqm 'add back y'
   $ hg l
   @  4 add back y
   |  y
   o  3 remove y
   |  y
   o  2 rename x to y
   |  x y
   | o  1 modify x
   |/   x
   o  0 add x
      x
   $ hg debugpathcopies 0 4
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 1
   grafting 1:* "modify x" (glob)
   file 'x' was deleted in local [local] but was modified in other [graft].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Add x, remove it, then add it back, then rename x to y. Similar to the case
 above, but here the break in history is before the rename.
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ hg rm x
   $ hg ci -qm 'remove x'
   $ echo x > x
   $ hg ci -Aqm 'add x again'
   $ hg mv x y
   $ hg ci -m 'rename x to y'
   $ hg l
   @  4 rename x to y
   |  x y
   o  3 add x again
   |  x
   o  2 remove x
   |  x
   | o  1 modify x
   |/   x
   o  0 add x
      x
   $ hg debugpathcopies 0 4
   x -> y
   $ hg graft -r 1
   grafting 1:* "modify x" (glob)
   merging y and x to y
   $ hg co -qC 1
   $ hg graft -r 4
   grafting 4:* "rename x to y" (glob)
   merging x and y to y
 
 Add x, modify it, remove it, then add it back, then rename x to y. Similar to
 the case above, but here the re-added file's nodeid is different from before
 the break.
 
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ echo x3 > x
   $ hg ci -qm 'modify x again'
   $ hg co -q 1
   $ hg rm x
   $ hg ci -qm 'remove x'
 # Same content to avoid conflicts
   $ hg revert -r 1 x
   $ hg ci -Aqm 'add x again'
   $ hg mv x y
   $ hg ci -m 'rename x to y'
   $ hg l
   @  5 rename x to y
   |  x y
   o  4 add x again
   |  x
   o  3 remove x
   |  x
   | o  2 modify x again
   |/   x
   o  1 modify x
   |  x
   o  0 add x
      x
   $ hg debugpathcopies 0 5
-  x -> y (no-filelog !)
-#if no-filelog
+  x -> y (no-filelog no-sidedata !)
+#if no-filelog no-sidedata
   $ hg graft -r 2
   grafting 2:* "modify x again" (glob)
   merging y and x to y
 #else
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 2
   grafting 2:* "modify x again" (glob)
   file 'x' was deleted in local [local] but was modified in other [graft].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 #endif
   $ hg co -qC 2
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 5
   grafting 5:* "rename x to y"* (glob)
   file 'x' was deleted in other [graft] but was modified in local [local].
   You can use (c)hanged version, (d)elete, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Add x, remove it, then add it back, rename x to y from the first commit.
 Similar to the case above, but here the break in history is parallel to the
 rename.
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ hg rm x
   $ hg ci -qm 'remove x'
   $ echo x > x
   $ hg ci -Aqm 'add x again'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ hg mv x y
   $ hg ci -qm 'rename x to y'
   $ hg l
   @  4 rename x to y
   |  x y
   | o  3 modify x
   | |  x
   | o  2 add x again
   | |  x
   | o  1 remove x
   |/   x
   o  0 add x
      x
   $ hg debugpathcopies 2 4
   x -> y
   $ hg graft -r 3
   grafting 3:* "modify x" (glob)
   merging y and x to y
   $ hg co -qC 3
   $ hg graft -r 4
   grafting 4:* "rename x to y" (glob)
   merging x and y to y
 
 Add x, remove it, then add it back, rename x to y from the first commit.
 Similar to the case above, but here the re-added file's nodeid is different
 from the base.
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ hg rm x
   $ hg ci -qm 'remove x'
   $ echo x2 > x
   $ hg ci -Aqm 'add x again with different content'
   $ hg co -q 0
   $ hg mv x y
   $ hg ci -qm 'rename x to y'
   $ hg l
   @  3 rename x to y
   |  x y
   | o  2 add x again with different content
   | |  x
   | o  1 remove x
   |/   x
   o  0 add x
      x
   $ hg debugpathcopies 2 3
   x -> y
 BROKEN: This should merge the changes from x into y
   $ hg graft -r 2
   grafting 2:* "add x again with different content" (glob)
   $ hg co -qC 2
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 3
   grafting 3:* "rename x to y" (glob)
   file 'x' was deleted in other [graft] but was modified in local [local].
   You can use (c)hanged version, (d)elete, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Add x on two branches, then rename x to y on one side. Similar to the case
 above, but here the break in history is via the base commit.
   $ newrepo
   $ echo a > a
   $ hg ci -Aqm 'base'
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ echo x > x
   $ hg ci -Aqm 'add x again'
   $ hg mv x y
   $ hg ci -qm 'rename x to y'
   $ hg l
   @  4 rename x to y
   |  x y
   o  3 add x again
   |  x
   | o  2 modify x
   | |  x
   | o  1 add x
   |/   x
   o  0 base
      a
   $ hg debugpathcopies 1 4
   x -> y
   $ hg graft -r 2
   grafting 2:* "modify x" (glob)
   merging y and x to y
   $ hg co -qC 2
   $ hg graft -r 4
   grafting 4:* "rename x to y"* (glob)
   merging x and y to y
 
 Add x on two branches, with same content but different history, then rename x
 to y on one side. Similar to the case above, here the file's nodeid is
 different between the branches.
   $ newrepo
   $ echo a > a
   $ hg ci -Aqm 'base'
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ echo x2 > x
   $ hg ci -m 'modify x'
   $ hg co -q 0
   $ touch x
   $ hg ci -Aqm 'add empty x'
 # Same content to avoid conflicts
   $ hg revert -r 1 x
   $ hg ci -m 'modify x to match commit 1'
   $ hg mv x y
   $ hg ci -qm 'rename x to y'
   $ hg l
   @  5 rename x to y
   |  x y
   o  4 modify x to match commit 1
   |  x
   o  3 add empty x
   |  x
   | o  2 modify x
   | |  x
   | o  1 add x
   |/   x
   o  0 base
      a
   $ hg debugpathcopies 1 5
-  x -> y (no-filelog !)
-#if filelog
+  x -> y (no-filelog no-sidedata !)
+#if no-filelog no-sidedata
+  $ hg graft -r 2
+  grafting 2:* "modify x" (glob)
+  merging y and x to y
+#else
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 2
   grafting 2:* "modify x" (glob)
   file 'x' was deleted in local [local] but was modified in other [graft].
   You can use (c)hanged version, leave (d)eleted, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
-#else
-  $ hg graft -r 2
-  grafting 2:* "modify x" (glob)
-  merging y and x to y
 #endif
   $ hg co -qC 2
 BROKEN: This should succeed and merge the changes from x into y
   $ hg graft -r 5
   grafting 5:* "rename x to y"* (glob)
   file 'x' was deleted in other [graft] but was modified in local [local].
   You can use (c)hanged version, (d)elete, or leave (u)nresolved.
   What do you want to do? u
   abort: unresolved conflicts, can't continue
   (use 'hg resolve' and 'hg graft --continue')
   [255]
 
 Copies via null revision (there shouldn't be any)
   $ newrepo
   $ echo x > x
   $ hg ci -Aqm 'add x'
   $ hg cp x y
   $ hg ci -m 'copy x to y'
   $ hg co -q null
   $ echo x > x
   $ hg ci -Aqm 'add x (again)'
   $ hg l
   @  2 add x (again)
      x
   o  1 copy x to y
   |  y
   o  0 add x
      x
   $ hg debugpathcopies 1 2
   $ hg debugpathcopies 2 1
   $ hg graft -r 1
   grafting 1:* "copy x to y" (glob)