test: extract the `genmerges` out of test-merge-combination.t

This open the way to splitting this slow test in multiple ones.

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

tests/testlib/merge-combination-util.sh

@@ -0,0 +1,73 b''
+# genmerges is the workhorse of the test-merge-combination.t tests.
+
+# Given:
+# - a `range` function describing the possible values for file a
+# - a `isgood` function to filter out uninteresting combination
+# - a `createfile` function to actually write the values for file a on the
+#   filesystem
+#
+# it print a series of lines that look like: abcd C: output of -T {files}
+# describing the file a at respectively the base, p2, p1, merge
+# revision. "C" indicates that hg merge had conflicts.
+
+genmerges () {
+
+  (LC_ALL=C type range | grep -q 'function') || (echo >&2 "missing function: range")
+  (LC_ALL=C type isgood | grep -q 'function') || (echo >&2 "missing function: isgood")
+  (LC_ALL=C type createfile | grep -q 'function') || (echo >&2 "missing function: createfile")
+
+  for base in `range` -; do
+    for r1 in `range $base` -; do
+      for r2 in `range $base $r1` -; do
+        for m in `range $base $r1 $r2` -; do
+          line="$base$r1$r2$m"
+          isgood $line || continue
+          hg init repo
+          cd repo
+          make_commit () {
+            v=$1; msg=$2; file=$3;
+            if [ $v != - ]; then
+              createfile $v
+            else
+              if [ -f a ]
+              then rm a
+              else touch $file
+              fi
+            fi
+            hg commit -q -Am $msg || exit 123
+          }
+          echo foo > foo
+          make_commit $base base b
+          make_commit $r1 r1 c
+          hg up -r 0 -q
+          make_commit $r2 r2 d
+          hg merge -q -r 1 > ../output 2>&1
+          if [ $? -ne 0 ]; then rm -f *.orig; hg resolve -m --all -q; fi
+          if [ -s ../output ]; then conflicts=" C"; else conflicts="  "; fi
+          make_commit $m m e
+          if [ $m = $r1 ] && [ $m = $r2 ]
+          then expected=
+          elif [ $m = $r1 ]
+          then if [ $base = $r2 ]
+               then expected=
+               else expected=a
+               fi
+          elif [ $m = $r2 ]
+          then if [ $base = $r1 ]
+               then expected=
+               else expected=a
+               fi
+          else expected=a
+          fi
+          got=`hg log -r 3 --template '{files}\n' | tr -d 'e '`
+          if [ "$got" = "$expected" ]
+          then echo "$line$conflicts: agree on \"$got\""
+          else echo "$line$conflicts: hg said \"$got\", expected \"$expected\""
+          fi
+          cd ../
+          rm -rf repo
+        done
+      done
+    done
+  done
+}

tests/test-merge-combination.t

@@ -1,220 +1,157 b''
 This file shows what hg says are "modified" files for a merge commit
 (hg log -T {files}), somewhat exhaustively.
 It shows merges that involves files contents changing, and merges that
 involve executable bit changing, but not merges with multiple or zero
 merge ancestors, nor copies/renames, and nor identical file contents
 with different filelog revisions.
 
-genmerges is the workhorse. Given:
-- a range function describing the possible values for file a
-- a isgood function to filter out uninteresting combination
-- a createfile function to actually write the values for file a on the
-filesystem
-it print a series of lines that look like: abcd C: output of -T {files}
-describing the file a at respectively the base, p2, p1, merge
-revision. "C" indicates that hg merge had conflicts.
-  $ genmerges () {
-  >   for base in `range` -; do
-  >     for r1 in `range $base` -; do
-  >       for r2 in `range $base $r1` -; do
-  >         for m in `range $base $r1 $r2` -; do
-  >           line="$base$r1$r2$m"
-  >           isgood $line || continue
-  >           hg init repo
-  >           cd repo
-  >           make_commit () {
-  >             v=$1; msg=$2; file=$3;
-  >             if [ $v != - ]; then
-  >               createfile $v
-  >             else
-  >               if [ -f a ]
-  >               then rm a
-  >               else touch $file
-  >               fi
-  >             fi
-  >             hg commit -q -Am $msg || exit 123
-  >           }
-  >           echo foo > foo
-  >           make_commit $base base b
-  >           make_commit $r1 r1 c
-  >           hg up -r 0 -q
-  >           make_commit $r2 r2 d
-  >           hg merge -q -r 1 > ../output 2>&1
-  >           if [ $? -ne 0 ]; then rm -f *.orig; hg resolve -m --all -q; fi
-  >           if [ -s ../output ]; then conflicts=" C"; else conflicts="  "; fi
-  >           make_commit $m m e
-  >           if [ $m = $r1 ] && [ $m = $r2 ]
-  >           then expected=
-  >           elif [ $m = $r1 ]
-  >           then if [ $base = $r2 ]
-  >                then expected=
-  >                else expected=a
-  >                fi
-  >           elif [ $m = $r2 ]
-  >           then if [ $base = $r1 ]
-  >                then expected=
-  >                else expected=a
-  >                fi
-  >           else expected=a
-  >           fi
-  >           got=`hg log -r 3 --template '{files}\n' | tr -d 'e '`
-  >           if [ "$got" = "$expected" ]
-  >           then echo "$line$conflicts: agree on \"$got\""
-  >           else echo "$line$conflicts: hg said \"$got\", expected \"$expected\""
-  >           fi
-  >           cd ../
-  >           rm -rf repo
-  >         done
-  >       done
-  >     done
-  >   done
-  > }
+  $ . $TESTDIR/testlib/merge-combination-util.sh
 
 All the merges of various file contents.
 
   $ range () {
   >   max=0
   >   for i in $@; do
   >     if [ $i = - ]; then continue; fi
   >     if [ $i -gt $max ]; then max=$i; fi
   >   done
   >   $TESTDIR/seq.py `expr $max + 1`
   > }
   $ isgood () { true; }
   $ createfile () {
   >   if [ -f a ] && [ "`cat a`" = $1 ]
   >   then touch $file
   >   else echo $v > a
   >   fi
   > }
 
   $ genmerges
   1111  : agree on ""
   1112  : agree on "a"
   111-  : agree on "a"
   1121  : agree on "a"
   1122  : agree on ""
   1123  : agree on "a"
   112-  : agree on "a"
   11-1  : hg said "", expected "a"
   11-2  : agree on "a"
   11--  : agree on ""
   1211  : agree on "a"
   1212  : agree on ""
   1213  : agree on "a"
   121-  : agree on "a"
   1221  : agree on "a"
   1222  : agree on ""
   1223  : agree on "a"
   122-  : agree on "a"
   1231 C: agree on "a"
   1232 C: agree on "a"
   1233 C: agree on "a"
   1234 C: agree on "a"
   123- C: agree on "a"
   12-1 C: agree on "a"
   12-2 C: hg said "", expected "a"
   12-3 C: agree on "a"
   12-- C: agree on "a"
   1-11  : hg said "", expected "a"
   1-12  : agree on "a"
   1-1-  : agree on ""
   1-21 C: agree on "a"
   1-22 C: hg said "", expected "a"
   1-23 C: agree on "a"
   1-2- C: agree on "a"
   1--1  : agree on "a"
   1--2  : agree on "a"
   1---  : agree on ""
   -111  : agree on ""
   -112  : agree on "a"
   -11-  : agree on "a"
   -121 C: agree on "a"
   -122 C: agree on "a"
   -123 C: agree on "a"
   -12- C: agree on "a"
   -1-1  : agree on ""
   -1-2  : agree on "a"
   -1--  : agree on "a"
   --11  : agree on ""
   --12  : agree on "a"
   --1-  : agree on "a"
   ---1  : agree on "a"
   ----  : agree on ""
 
 All the merges of executable bit.
 
   $ range () {
   >   max=a
   >   for i in $@; do
   >     if [ $i = - ]; then continue; fi
   >     if [ $i > $max ]; then max=$i; fi
   >   done
   >   if [ $max = a ]; then echo f; else echo f x; fi
   > }
   $ isgood () { case $line in *f*x*) true;; *) false;; esac; }
   $ createfile () {
   >   if [ -f a ] && (([ -x a ] && [ $v = x ]) || (! [ -x a ] && [ $v != x ]))
   >   then touch $file
   >   else touch a; if [ $v = x ]; then chmod +x a; else chmod -x a; fi
   >   fi
   > }
 
 #if execbit
   $ genmerges
   fffx  : agree on "a"
   ffxf  : agree on "a"
   ffxx  : agree on ""
   ffx-  : agree on "a"
   ff-x  : hg said "", expected "a"
   fxff  : hg said "", expected "a"
   fxfx  : hg said "a", expected ""
   fxf-  : agree on "a"
   fxxf  : agree on "a"
   fxxx  : agree on ""
   fxx-  : agree on "a"
   fx-f  : hg said "", expected "a"
   fx-x  : hg said "", expected "a"
   fx--  : hg said "", expected "a"
   f-fx  : agree on "a"
   f-xf  : agree on "a"
   f-xx  : hg said "", expected "a"
   f-x-  : agree on "a"
   f--x  : agree on "a"
   -ffx  : agree on "a"
   -fxf C: agree on "a"
   -fxx C: hg said "", expected "a"
   -fx- C: agree on "a"
   -f-x  : hg said "", expected "a"
   --fx  : agree on "a"
 #endif
 
 Files modified or cleanly merged, with no greatest common ancestors:
 
   $ hg init repo; cd repo
   $ touch a0 b0; hg commit -qAm 0
   $ hg up -qr null; touch a1 b1; hg commit -qAm 1
   $ hg merge -qr 0; rm b*; hg commit -qAm 2
   $ hg log -r . -T '{files}\n'
   b0 b1
   $ cd ../
   $ rm -rf repo
 
 A few cases of criss-cross merges involving deletions (listing all
 such merges is probably too much). Both gcas contain $files, so we
 expect the final merge to behave like a merge with a single gca
 containing $files.
 
   $ hg init repo; cd repo
   $ files="c1 u1 c2 u2"
   $ touch $files; hg commit -qAm '0 root'
   $ for f in $files; do echo f > $f; done; hg commit -qAm '1 gca1'
   $ hg up -qr0; hg revert -qr 1 --all; hg commit -qAm '2 gca2'
   $ hg up -qr 1; hg merge -qr 2; rm *1; hg commit -qAm '3 p1'
   $ hg up -qr 2; hg merge -qr 1; rm *2; hg commit -qAm '4 p2'
   $ hg merge -qr 3; echo f > u1; echo f > u2; rm -f c1 c2
   $ hg commit -qAm '5 merge with two gcas'
   $ hg log -r . -T '{files}\n' # expecting u1 u2
   
   $ cd ../
   $ rm -rf repo