X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=t%2Ft1000-read-tree-m-3way.sh;h=d0af8c3d52573fea203aab13612a9103cca78dd9;hb=efca578eec57869994da0982e05dcf1dee0bc213;hp=d7f900969a5f6be4ad8f6a7e5a3c4ed6531a41f7;hpb=2ecd90502f4615c4f1a9340dfaed3f78ecd23747;p=git.git

diff --git a/t/t1000-read-tree-m-3way.sh b/t/t1000-read-tree-m-3way.sh
old mode 100644
new mode 100755
index d7f90096..d0af8c3d
--- a/t/t1000-read-tree-m-3way.sh
+++ b/t/t1000-read-tree-m-3way.sh
@@ -71,243 +71,444 @@ In addition:
  DF: a special case, where A makes a directory and B makes a file.
 
 '
-
 . ./test-lib.sh
+. ../lib-read-tree-m-3way.sh
 
-# Original tree.
-mkdir Z
-for a in N D M
-do
-    for b in N D M
-    do
-        p=$a$b
-	echo This is $p from the original tree. >$p
-	echo This is Z/$p from the original tree. >Z/$p
-	test_expect_success \
-	    "adding test file $p and Z/$p" \
-	    'git-update-cache --add $p &&
-	    git-update-cache --add Z/$p'
-    done
-done
-echo This is SS from the original tree. >SS
-test_expect_success \
-    'adding test file SS' \
-    'git-update-cache --add SS'
-cat >TT <<\EOF
-This is a trivial merge sample text.
-Branch A is expected to upcase this word, here.
-There are some filler lines to avoid diff context
-conflicts here,
-like this one,
-and this one,
-and this one is yet another one of them.
-At the very end, here comes another line, that is
-the word, expected to be upcased by Branch B.
-This concludes the trivial merge sample file.
-EOF
-test_expect_success \
-    'adding test file TT' \
-    'git-update-cache --add TT'
-test_expect_success \
-    'prepare initial tree' \
-    'tree_O=$(git-write-tree)'
+################################################################
+# Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
+# and #5ALT trivial merges.
 
-test_expect_success \
-    'commit initial tree' \
-    'commit_O=$(echo "Original tree for the merge test." |
-     git-commit-tree $tree_O)'
-echo $commit_O >.git/HEAD-O
+cat >expected <<\EOF
+100644 X 2	AA
+100644 X 3	AA
+100644 X 0	AN
+100644 X 1	DD
+100644 X 3	DF
+100644 X 2	DF/DF
+100644 X 1	DM
+100644 X 3	DM
+100644 X 1	DN
+100644 X 3	DN
+100644 X 0	LL
+100644 X 1	MD
+100644 X 2	MD
+100644 X 1	MM
+100644 X 2	MM
+100644 X 3	MM
+100644 X 0	MN
+100644 X 0	NA
+100644 X 1	ND
+100644 X 2	ND
+100644 X 0	NM
+100644 X 0	NN
+100644 X 0	SS
+100644 X 1	TT
+100644 X 2	TT
+100644 X 3	TT
+100644 X 2	Z/AA
+100644 X 3	Z/AA
+100644 X 0	Z/AN
+100644 X 1	Z/DD
+100644 X 1	Z/DM
+100644 X 3	Z/DM
+100644 X 1	Z/DN
+100644 X 3	Z/DN
+100644 X 1	Z/MD
+100644 X 2	Z/MD
+100644 X 1	Z/MM
+100644 X 2	Z/MM
+100644 X 3	Z/MM
+100644 X 0	Z/MN
+100644 X 0	Z/NA
+100644 X 1	Z/ND
+100644 X 2	Z/ND
+100644 X 0	Z/NM
+100644 X 0	Z/NN
+EOF
 
-################################################################
-# Branch A and B makes the changes according to the above matrix.
+_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
+_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
 
-################################################################
-# Branch A
+check_result () {
+    git-ls-files --stage | sed -e 's/ '"$_x40"' / X /' >current &&
+    diff -u expected current
+}
 
-to_remove=$(echo D? Z/D?)
-rm -f $to_remove
+# This is done on an empty work directory, which is the normal
+# merge person behaviour.
 test_expect_success \
-    'change in branch A (removal)' \
-    'git-update-cache --remove $to_remove'
-
-for p in M? Z/M?
-do
-    echo This is modified $p in the branch A. >$p
-    test_expect_success \
-	'change in branch A (modification)' \
-        "git-update-cache $p"
-done
-
-for p in AN AA Z/AN Z/AA
-do
-    echo This is added $p in the branch A. >$p
-    test_expect_success \
-	'change in branch A (addition)' \
-	"git-update-cache --add $p"
-done
-
-echo This is SS from the modified tree. >SS
-echo This is LL from the modified tree. >LL
+    '3-way merge with git-read-tree -m, empty cache' \
+    "rm -fr [NDMALTS][NDMALTSF] Z &&
+     rm .git/index &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+# This starts out with the first head, which is the normal
+# patch submitter behaviour.
 test_expect_success \
-    'change in branch A (addition)' \
-    'git-update-cache --add LL &&
-     git-update-cache SS'
-mv TT TT-
-sed -e '/Branch A/s/word/WORD/g' <TT- >TT
-rm -f TT-
-test_expect_success \
-    'change in branch A (edit)' \
-    'git-update-cache TT'
+    '3-way merge with git-read-tree -m, match H' \
+    "rm -fr [NDMALTS][NDMALTSF] Z &&
+     rm .git/index &&
+     git-read-tree $tree_A &&
+     git-checkout-index -f -u -a &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+: <<\END_OF_CASE_TABLE
+
+We have so far tested only empty index and clean-and-matching-A index
+case which are trivial.  Make sure index requirements are also
+checked.
+
+"git-read-tree -m O A B"
+
+     O       A       B         result      index requirements
+-------------------------------------------------------------------
+  1  missing missing missing   -           must not exist.
+ ------------------------------------------------------------------
+  2  missing missing exists    take B*     must match B, if exists.
+ ------------------------------------------------------------------
+  3  missing exists  missing   take A*     must match A, if exists.
+ ------------------------------------------------------------------
+  4  missing exists  A!=B      no merge    must match A and be
+                                           up-to-date, if exists.
+ ------------------------------------------------------------------
+  5  missing exists  A==B      take A      must match A, if exists.
+ ------------------------------------------------------------------
+  6  exists  missing missing   remove      must not exist.
+ ------------------------------------------------------------------
+  7  exists  missing O!=B      no merge    must not exist.
+ ------------------------------------------------------------------
+  8  exists  missing O==B      remove      must not exist.
+ ------------------------------------------------------------------
+  9  exists  O!=A    missing   no merge    must match A and be
+                                           up-to-date, if exists.
+ ------------------------------------------------------------------
+ 10  exists  O==A    missing   remove      ditto
+ ------------------------------------------------------------------
+ 11  exists  O!=A    O!=B      no merge    must match A and be
+                     A!=B                  up-to-date, if exists.
+ ------------------------------------------------------------------
+ 12  exists  O!=A    O!=B      take A      must match A, if exists.
+                     A==B
+ ------------------------------------------------------------------
+ 13  exists  O!=A    O==B      take A      must match A, if exists.
+ ------------------------------------------------------------------
+ 14  exists  O==A    O!=B      take B      if exists, must either (1)
+                                           match A and be up-to-date,
+                                           or (2) match B.
+ ------------------------------------------------------------------
+ 15  exists  O==A    O==B      take B      must match A if exists.
+ ------------------------------------------------------------------
+ 16  exists  O==A    O==B      barf        must match A if exists.
+     *multi* in one  in another
+-------------------------------------------------------------------
+
+Note: we need to be careful in case 2 and 3.  The tree A may contain
+DF (file) when tree B require DF to be a directory by having DF/DF
+(file).
+
+END_OF_CASE_TABLE
+
+test_expect_failure \
+    '1 - must not have an entry not in A.' \
+    "rm -f .git/index XX &&
+     echo XX >XX &&
+     git-update-index --add XX &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-mkdir DF
-echo Branch A makes a file at DF/DF, creating a directory DF. >DF/DF
 test_expect_success \
-    'change in branch A (change file to directory)' \
-    'git-update-cache --add DF/DF'
+    '2 - must match B in !O && !A && B case.' \
+    "rm -f .git/index NA &&
+     cp .orig-B/NA NA &&
+     git-update-index --add NA &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
 test_expect_success \
-    'recording branch A tree' \
-    'tree_A=$(git-write-tree)'
+    '2 - matching B alone is OK in !O && !A && B case.' \
+    "rm -f .git/index NA &&
+     cp .orig-B/NA NA &&
+     git-update-index --add NA &&
+     echo extra >>NA &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
 test_expect_success \
-    'committing branch A changes' \
-    'commit_A=$(echo "Branch A for the merge test." |
-           git-commit-tree $tree_A -p $commit_O)'
-echo $commit_A >.git/HEAD-A
-	   
-################################################################
-# Branch B
-# Start from O
+    '3 - must match A in !O && A && !B case.' \
+    "rm -f .git/index AN &&
+     cp .orig-A/AN AN &&
+     git-update-index --add AN &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
-rm -rf [NDMASLT][NDMASLT] Z DF
-mkdir Z
 test_expect_success \
-    'reading original tree and checking out' \
-    'git-read-tree $tree_O &&
-     git-checkout-cache -a'
+    '3 - matching A alone is OK in !O && A && !B case.' \
+    "rm -f .git/index AN &&
+     cp .orig-A/AN AN &&
+     git-update-index --add AN &&
+     echo extra >>AN &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '3 (fail) - must match A in !O && A && !B case.' \
+    "rm -f .git/index AN &&
+     cp .orig-A/AN AN &&
+     echo extra >>AN &&
+     git-update-index --add AN &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-to_remove=$(echo ?D Z/?D)
-rm -f $to_remove
 test_expect_success \
-    'change in branch B (removal)' \
-    "git-update-cache --remove $to_remove"
-
-for p in ?M Z/?M
-do
-    echo This is modified $p in the branch B. >$p
-    test_expect_success \
-	'change in branch B (modification)' \
-	"git-update-cache $p"
-done
-
-for p in NA AA Z/NA Z/AA
-do
-    echo This is added $p in the branch B. >$p
-    test_expect_success \
-	'change in branch B (addition)' \
-	"git-update-cache --add $p"
-done
-echo This is SS from the modified tree. >SS
-echo This is LL from the modified tree. >LL
+    '4 - must match and be up-to-date in !O && A && B && A!=B case.' \
+    "rm -f .git/index AA &&
+     cp .orig-A/AA AA &&
+     git-update-index --add AA &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
+    "rm -f .git/index AA &&
+     cp .orig-A/AA AA &&
+     git-update-index --add AA &&
+     echo extra >>AA &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
+    "rm -f .git/index AA &&
+     cp .orig-A/AA AA &&
+     echo extra >>AA &&
+     git-update-index --add AA &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
 test_expect_success \
-    'change in branch B (addition and modification)' \
-    'git-update-cache --add LL &&
-     git-update-cache SS'
-mv TT TT-
-sed -e '/Branch B/s/word/WORD/g' <TT- >TT
-rm -f TT-
+    '5 - must match in !O && A && B && A==B case.' \
+    "rm -f .git/index LL &&
+     cp .orig-A/LL LL &&
+     git-update-index --add LL &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
 test_expect_success \
-    'change in branch B (modification)' \
-    'git-update-cache TT'
+    '5 - must match in !O && A && B && A==B case.' \
+    "rm -f .git/index LL &&
+     cp .orig-A/LL LL &&
+     git-update-index --add LL &&
+     echo extra >>LL &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '5 (fail) - must match A in !O && A && B && A==B case.' \
+    "rm -f .git/index LL &&
+     cp .orig-A/LL LL &&
+     echo extra >>LL &&
+     git-update-index --add LL &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '6 - must not exist in O && !A && !B case' \
+    "rm -f .git/index DD &&
+     echo DD >DD
+     git-update-index --add DD &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '7 - must not exist in O && !A && B && O!=B case' \
+    "rm -f .git/index DM &&
+     cp .orig-B/DM DM &&
+     git-update-index --add DM &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '8 - must not exist in O && !A && B && O==B case' \
+    "rm -f .git/index DN &&
+     cp .orig-B/DN DN &&
+     git-update-index --add DN &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-echo Branch B makes a file at DF. >DF
 test_expect_success \
-    'change in branch B (addition of a file to conflict with directory)' \
-    'git-update-cache --add DF'
+    '9 - must match and be up-to-date in O && A && !B && O!=A case' \
+    "rm -f .git/index MD &&
+     cp .orig-A/MD MD &&
+     git-update-index --add MD &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
+    "rm -f .git/index MD &&
+     cp .orig-A/MD MD &&
+     git-update-index --add MD &&
+     echo extra >>MD &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
+    "rm -f .git/index MD &&
+     cp .orig-A/MD MD &&
+     echo extra >>MD &&
+     git-update-index --add MD &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
 test_expect_success \
-    'recording branch B tree' \
-    'tree_B=$(git-write-tree)'
+    '10 - must match and be up-to-date in O && A && !B && O==A case' \
+    "rm -f .git/index ND &&
+     cp .orig-A/ND ND &&
+     git-update-index --add ND &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
+    "rm -f .git/index ND &&
+     cp .orig-A/ND ND &&
+     git-update-index --add ND &&
+     echo extra >>ND &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
+    "rm -f .git/index ND &&
+     cp .orig-A/ND ND &&
+     echo extra >>ND &&
+     git-update-index --add ND &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
 test_expect_success \
-    'committing branch B changes' \
-    'commit_B=$(echo "Branch B for the merge test." |
-           git-commit-tree $tree_B -p $commit_O)'
-echo $commit_B >.git/HEAD-B
+    '11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
+    "rm -f .git/index MM &&
+     cp .orig-A/MM MM &&
+     git-update-index --add MM &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
+    "rm -f .git/index MM &&
+     cp .orig-A/MM MM &&
+     git-update-index --add MM &&
+     echo extra >>MM &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
+    "rm -f .git/index MM &&
+     cp .orig-A/MM MM &&
+     echo extra >>MM &&
+     git-update-index --add MM &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-################################################################
-# Done preparation.
+test_expect_success \
+    '12 - must match A in O && A && B && O!=A && A==B case' \
+    "rm -f .git/index SS &&
+     cp .orig-A/SS SS &&
+     git-update-index --add SS &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
-test_debug '
-    for T in O A B
-    do
-	echo "# $T $(eval git-cat-file commit \$commit_$T | sed -e 1q)"
-    done
-'
+test_expect_success \
+    '12 - must match A in O && A && B && O!=A && A==B case' \
+    "rm -f .git/index SS &&
+     cp .orig-A/SS SS &&
+     git-update-index --add SS &&
+     echo extra >>SS &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '12 (fail) - must match A in O && A && B && O!=A && A==B case' \
+    "rm -f .git/index SS &&
+     cp .orig-A/SS SS &&
+     echo extra >>SS &&
+     git-update-index --add SS &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-################################################################
-# Try merging and showing the various diffs
+test_expect_success \
+    '13 - must match A in O && A && B && O!=A && O==B case' \
+    "rm -f .git/index MN &&
+     cp .orig-A/MN MN &&
+     git-update-index --add MN &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
 test_expect_success \
-    '3-way merge with git-read-tree -m' \
-    "git-read-tree -m $tree_O $tree_A $tree_B"
+    '13 - must match A in O && A && B && O!=A && O==B case' \
+    "rm -f .git/index MN &&
+     cp .orig-A/MN MN &&
+     git-update-index --add MN &&
+     echo extra >>MN &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
-strip_object_id='s/^\([0-7]*\) [0-9a-f]* \([0-3].*\)$/\1 \2/'
+test_expect_success \
+    '14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
+    "rm -f .git/index NM &&
+     cp .orig-A/NM NM &&
+     git-update-index --add NM &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
 test_expect_success \
-    'git-ls-files --stage of the merge result' \
-    'git-ls-files --stage >current- &&
-     sed -e "$strip_object_id" <current- >current'
+    '14 - may match B in O && A && B && O==A && O!=B case' \
+    "rm -f .git/index NM &&
+     cp .orig-B/NM NM &&
+     git-update-index --add NM &&
+     echo extra >>NM &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
+    "rm -f .git/index NM &&
+     cp .orig-A/NM NM &&
+     git-update-index --add NM &&
+     echo extra >>NM &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+test_expect_failure \
+    '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
+    "rm -f .git/index NM &&
+     cp .orig-A/NM NM &&
+     echo extra >>NM &&
+     git-update-index --add NM &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
 
-cat >expected <<\EOF
-100644 2 AA
-100644 3 AA
-100644 2 AN
-100644 1 DD
-100644 3 DF
-100644 2 DF/DF
-100644 1 DM
-100644 3 DM
-100644 1 DN
-100644 3 DN
-100644 2 LL
-100644 3 LL
-100644 1 MD
-100644 2 MD
-100644 1 MM
-100644 2 MM
-100644 3 MM
-100644 0 MN
-100644 3 NA
-100644 1 ND
-100644 2 ND
-100644 0 NM
-100644 0 NN
-100644 0 SS
-100644 1 TT
-100644 2 TT
-100644 3 TT
-100644 2 Z/AA
-100644 3 Z/AA
-100644 2 Z/AN
-100644 1 Z/DD
-100644 1 Z/DM
-100644 3 Z/DM
-100644 1 Z/DN
-100644 3 Z/DN
-100644 1 Z/MD
-100644 2 Z/MD
-100644 1 Z/MM
-100644 2 Z/MM
-100644 3 Z/MM
-100644 0 Z/MN
-100644 3 Z/NA
-100644 1 Z/ND
-100644 2 Z/ND
-100644 0 Z/NM
-100644 0 Z/NN
-EOF
+test_expect_success \
+    '15 - must match A in O && A && B && O==A && O==B case' \
+    "rm -f .git/index NN &&
+     cp .orig-A/NN NN &&
+     git-update-index --add NN &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
 
 test_expect_success \
-    'validate merge result' \
-    'diff current expected'
+    '15 - must match A in O && A && B && O==A && O==B case' \
+    "rm -f .git/index NN &&
+     cp .orig-A/NN NN &&
+     git-update-index --add NN &&
+     echo extra >>NN &&
+     git-read-tree -m $tree_O $tree_A $tree_B &&
+     check_result"
+
+test_expect_failure \
+    '15 (fail) - must match A in O && A && B && O==A && O==B case' \
+    "rm -f .git/index NN &&
+     cp .orig-A/NN NN &&
+     echo extra >>NN &&
+     git-update-index --add NN &&
+     git-read-tree -m $tree_O $tree_A $tree_B"
+
+# #16
+test_expect_success \
+    '16 - A matches in one and B matches in another.' \
+    'rm -f .git/index F16 &&
+    echo F16 >F16 &&
+    git-update-index --add F16 &&
+    tree0=`git-write-tree` &&
+    echo E16 >F16 &&
+    git-update-index F16 &&
+    tree1=`git-write-tree` &&
+    git-read-tree -m $tree0 $tree1 $tree1 $tree0 &&
+    git-ls-files --stage'
 
 test_done