[thirdparty/git.git] / t / t1000-read-tree-m-3way.sh

#!/bin/sh
#
# Copyright (c) 2005 Junio C Hamano
#

test_description='Three way merge with read-tree -m

This test tries three-way merge with read-tree -m

There is one ancestor (called O for Original) and two branches A
and B derived from it.  We want to do a 3-way merge between A and
B, using O as the common ancestor.

    merge A O B

Decisions are made by comparing contents of O, A and B pathname
by pathname.  The result is determined by the following guiding
principle:

 - If only A does something to it and B does not touch it, take
   whatever A does.

 - If only B does something to it and A does not touch it, take
   whatever B does.

 - If both A and B does something but in the same way, take
   whatever they do.

 - If A and B does something but different things, we need a
   3-way merge:

   - We cannot do anything about the following cases:

     * O does not have it.  A and B both must be adding to the
       same path independently.

     * A deletes it.  B must be modifying.

   - Otherwise, A and B are modifying.  Run 3-way merge.

First, the case matrix.

 - Vertical axis is for A'\''s actions.
 - Horizontal axis is for B'\''s actions.

.----------------------------------------------------------------.
| A        B | No Action  |   Delete   |   Modify   |    Add     |
|------------+------------+------------+------------+------------|
| No Action  |            |            |            |            |
|            | select O   | delete     | select B   | select B   |
|            |            |            |            |            |
|------------+------------+------------+------------+------------|
| Delete     |            |            | ********** |    can     |
|            | delete     | delete     | merge      |    not     |
|            |            |            |            |  happen    |
|------------+------------+------------+------------+------------|
| Modify     |            | ********** | ?????????? |    can     |
|            | select A   | merge      | select A=B |    not     |
|            |            |            | merge      |  happen    |
|------------+------------+------------+------------+------------|
| Add        |            |    can     |    can     | ?????????? |
|            | select A   |    not     |    not     | select A=B |
|            |            |  happen    |  happen    | merge      |
.----------------------------------------------------------------.

In addition:

 SS: a special case of MM, where A and B makes the same modification.
 LL: a special case of AA, where A and B creates the same file.
 TT: a special case of MM, where A and B makes mergeable changes.
 DF: a special case, where A makes a directory and B makes a file.

'
. ./test-lib.sh
. "$TEST_DIRECTORY"/lib-read-tree.sh
. "$TEST_DIRECTORY"/lib-read-tree-m-3way.sh

################################################################
# Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
# and #5ALT trivial merges.

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

check_result () {
	git ls-files --stage | sed -e 's/ '"$OID_REGEX"' / X /' >current &&
	test_cmp expected current
}

# This is done on an empty work directory, which is the normal
# merge person behaviour.
test_expect_success '3-way merge with git read-tree -m, empty cache' '
	rm -fr [NDMALTS][NDMALTSF] Z &&
	rm .git/index &&
	read_tree_must_succeed -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 '3-way merge with git read-tree -m, match H' '
	rm -fr [NDMALTS][NDMALTSF] Z &&
	rm .git/index &&
	read_tree_must_succeed $tree_A &&
	git checkout-index -f -u -a &&
	read_tree_must_succeed -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   no merge    must match A
 ------------------------------------------------------------------
 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_success '1 - must not have an entry not in A.' '
	rm -f .git/index XX &&
	echo XX >XX &&
	git update-index --add XX &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '2 - must match B in !O && !A && B case.' '
	rm -f .git/index NA &&
	cp .orig-B/NA NA &&
	git update-index --add NA &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B
'

test_expect_success '3 - must match A in !O && A && !B case.' '
	rm -f .git/index AN &&
	cp .orig-A/AN AN &&
	git update-index --add AN &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '6 - must not exist in O && !A && !B case' '
	rm -f .git/index DD &&
	echo DD >DD &&
	git update-index --add DD &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

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 &&
	echo extra >>MN &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

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 &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

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 &&
	echo extra >>NN &&
	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	check_result
'

test_expect_success '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 &&
	read_tree_must_fail -m $tree_O $tree_A $tree_B
'

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) &&
	read_tree_must_succeed -m $tree0 $tree1 $tree1 $tree0 &&
	git ls-files --stage
'

test_done
Commit	Line	Data
2ecd9050 JH	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2005 Junio C Hamano
	4	#
	5
	6	test_description='Three way merge with read-tree -m
	7
	8	This test tries three-way merge with read-tree -m
	9
	10	There is one ancestor (called O for Original) and two branches A
	11	and B derived from it. We want to do a 3-way merge between A and
	12	B, using O as the common ancestor.
	13
	14	merge A O B
	15
	16	Decisions are made by comparing contents of O, A and B pathname
	17	by pathname. The result is determined by the following guiding
	18	principle:
	19
	20	- If only A does something to it and B does not touch it, take
	21	whatever A does.
	22
	23	- If only B does something to it and A does not touch it, take
	24	whatever B does.
	25
	26	- If both A and B does something but in the same way, take
	27	whatever they do.
	28
	29	- If A and B does something but different things, we need a
	30	3-way merge:
	31
	32	- We cannot do anything about the following cases:
	33
	34	* O does not have it. A and B both must be adding to the
	35	same path independently.
	36
	37	* A deletes it. B must be modifying.
	38
	39	- Otherwise, A and B are modifying. Run 3-way merge.
	40
	41	First, the case matrix.
	42
	43	- Vertical axis is for A'\''s actions.
	44	- Horizontal axis is for B'\''s actions.
	45
	46	.----------------------------------------------------------------.
	47	\| A B \| No Action \| Delete \| Modify \| Add \|
	48	\|------------+------------+------------+------------+------------\|
	49	\| No Action \| \| \| \| \|
	50	\| \| select O \| delete \| select B \| select B \|
	51	\| \| \| \| \| \|
	52	\|------------+------------+------------+------------+------------\|
	53	\| Delete \| \| \| ********** \| can \|
	54	\| \| delete \| delete \| merge \| not \|
	55	\| \| \| \| \| happen \|
	56	\|------------+------------+------------+------------+------------\|
	57	\| Modify \| \| ********** \| ?????????? \| can \|
	58	\| \| select A \| merge \| select A=B \| not \|
	59	\| \| \| \| merge \| happen \|
	60	\|------------+------------+------------+------------+------------\|
	61	\| Add \| \| can \| can \| ?????????? \|
	62	\| \| select A \| not \| not \| select A=B \|
	63	\| \| \| happen \| happen \| merge \|
	64	.----------------------------------------------------------------.
65
66	In addition:
67
68	SS: a special case of MM, where A and B makes the same modification.
69	LL: a special case of AA, where A and B creates the same file.
70	TT: a special case of MM, where A and B makes mergeable changes.
71	DF: a special case, where A makes a directory and B makes a file.
72
73	'
2ecd9050	74	. ./test-lib.sh
ea5070c9	75	. "$TEST_DIRECTORY"/lib-read-tree.sh
bfdbee98	76	. "$TEST_DIRECTORY"/lib-read-tree-m-3way.sh
2ecd9050 JH	77
2ecd9050 JH	78	################################################################
32192e66 JH	79	# Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
32192e66 JH	80	# and #5ALT trivial merges.
2ecd9050	81
2ecd9050	82	cat >expected <<\EOF
2eab945e JH	83	100644 X 2 AA
2eab945e JH	84	100644 X 3 AA
32192e66	85	100644 X 0 AN
2eab945e JH	86	100644 X 1 DD
	87	100644 X 3 DF
	88	100644 X 2 DF/DF
	89	100644 X 1 DM
	90	100644 X 3 DM
	91	100644 X 1 DN
	92	100644 X 3 DN
e7f9bc41	93	100644 X 0 LL
2eab945e JH	94	100644 X 1 MD
	95	100644 X 2 MD
	96	100644 X 1 MM
	97	100644 X 2 MM
	98	100644 X 3 MM
	99	100644 X 0 MN
32192e66	100	100644 X 0 NA
2eab945e JH	101	100644 X 1 ND
	102	100644 X 2 ND
	103	100644 X 0 NM
	104	100644 X 0 NN
	105	100644 X 0 SS
	106	100644 X 1 TT
	107	100644 X 2 TT
	108	100644 X 3 TT
	109	100644 X 2 Z/AA
	110	100644 X 3 Z/AA
32192e66	111	100644 X 0 Z/AN
2eab945e JH	112	100644 X 1 Z/DD
	113	100644 X 1 Z/DM
	114	100644 X 3 Z/DM
	115	100644 X 1 Z/DN
	116	100644 X 3 Z/DN
	117	100644 X 1 Z/MD
	118	100644 X 2 Z/MD
	119	100644 X 1 Z/MM
	120	100644 X 2 Z/MM
	121	100644 X 3 Z/MM
	122	100644 X 0 Z/MN
32192e66	123	100644 X 0 Z/NA
2eab945e JH	124	100644 X 1 Z/ND
	125	100644 X 2 Z/ND
	126	100644 X 0 Z/NM
	127	100644 X 0 Z/NN
2ecd9050 JH	128	EOF
2ecd9050 JH	129
f225b218	130	check_result () {
2ece6ad2	131	git ls-files --stage \| sed -e 's/ '"$OID_REGEX"' / X /' >current &&
0b8b25f6	132	test_cmp expected current
f225b218	133	}
7d95ee93 JH	134
	135	# This is done on an empty work directory, which is the normal
	136	# merge person behaviour.
0b8b25f6 SB	137	test_expect_success '3-way merge with git read-tree -m, empty cache' '
	138	rm -fr [NDMALTS][NDMALTSF] Z &&
	139	rm .git/index &&
	140	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	141	check_result
	142	'
7d95ee93 JH	143
	144	# This starts out with the first head, which is the normal
	145	# patch submitter behaviour.
0b8b25f6 SB	146	test_expect_success '3-way merge with git read-tree -m, match H' '
	147	rm -fr [NDMALTS][NDMALTSF] Z &&
	148	rm .git/index &&
	149	read_tree_must_succeed $tree_A &&
	150	git checkout-index -f -u -a &&
	151	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	152	check_result
	153	'
f225b218 JH	154
	155	: <<\END_OF_CASE_TABLE
	156
	157	We have so far tested only empty index and clean-and-matching-A index
	158	case which are trivial. Make sure index requirements are also
3e03aaf5	159	checked.
f225b218	160
5be60078	161	"git read-tree -m O A B"
f225b218 JH	162
	163	O A B result index requirements
	164	-------------------------------------------------------------------
	165	1 missing missing missing - must not exist.
	166	------------------------------------------------------------------
3e03aaf5	167	2 missing missing exists take B* must match B, if exists.
f225b218	168	------------------------------------------------------------------
3e03aaf5	169	3 missing exists missing take A* must match A, if exists.
f225b218 JH	170	------------------------------------------------------------------
	171	4 missing exists A!=B no merge must match A and be
	172	up-to-date, if exists.
	173	------------------------------------------------------------------
3e03aaf5	174	5 missing exists A==B take A must match A, if exists.
f225b218	175	------------------------------------------------------------------
3e03aaf5	176	6 exists missing missing remove must not exist.
f225b218 JH	177	------------------------------------------------------------------
	178	7 exists missing O!=B no merge must not exist.
	179	------------------------------------------------------------------
3e03aaf5	180	8 exists missing O==B remove must not exist.
f225b218 JH	181	------------------------------------------------------------------
	182	9 exists O!=A missing no merge must match A and be
	183	up-to-date, if exists.
	184	------------------------------------------------------------------
ea4b52a8	185	10 exists O==A missing no merge must match A
f225b218 JH	186	------------------------------------------------------------------
	187	11 exists O!=A O!=B no merge must match A and be
	188	A!=B up-to-date, if exists.
	189	------------------------------------------------------------------
	190	12 exists O!=A O!=B take A must match A, if exists.
	191	A==B
	192	------------------------------------------------------------------
	193	13 exists O!=A O==B take A must match A, if exists.
	194	------------------------------------------------------------------
3e03aaf5	195	14 exists O==A O!=B take B if exists, must either (1)
f225b218 JH	196	match A and be up-to-date,
	197	or (2) match B.
	198	------------------------------------------------------------------
	199	15 exists O==A O==B take B must match A if exists.
4d3fe0c5 JH	200	------------------------------------------------------------------
	201	16 exists O==A O==B barf must match A if exists.
	202	multi in one in another
f225b218 JH	203	-------------------------------------------------------------------
f225b218 JH	204
3e03aaf5 JH	205	Note: we need to be careful in case 2 and 3. The tree A may contain
	206	DF (file) when tree B require DF to be a directory by having DF/DF
	207	(file).
f225b218 JH	208
	209	END_OF_CASE_TABLE
	210
0b8b25f6 SB	211	test_expect_success '1 - must not have an entry not in A.' '
	212	rm -f .git/index XX &&
	213	echo XX >XX &&
	214	git update-index --add XX &&
	215	read_tree_must_fail -m $tree_O $tree_A $tree_B
	216	'
	217
	218	test_expect_success '2 - must match B in !O && !A && B case.' '
	219	rm -f .git/index NA &&
	220	cp .orig-B/NA NA &&
	221	git update-index --add NA &&
	222	read_tree_must_succeed -m $tree_O $tree_A $tree_B
	223	'
	224
	225	test_expect_success '2 - matching B alone is OK in !O && !A && B case.' '
	226	rm -f .git/index NA &&
	227	cp .orig-B/NA NA &&
	228	git update-index --add NA &&
	229	echo extra >>NA &&
	230	read_tree_must_succeed -m $tree_O $tree_A $tree_B
	231	'
	232
	233	test_expect_success '3 - must match A in !O && A && !B case.' '
	234	rm -f .git/index AN &&
	235	cp .orig-A/AN AN &&
	236	git update-index --add AN &&
	237	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	238	check_result
	239	'
	240
	241	test_expect_success '3 - matching A alone is OK in !O && A && !B case.' '
	242	rm -f .git/index AN &&
	243	cp .orig-A/AN AN &&
	244	git update-index --add AN &&
	245	echo extra >>AN &&
	246	read_tree_must_succeed -m $tree_O $tree_A $tree_B
	247	'
	248
	249	test_expect_success '3 (fail) - must match A in !O && A && !B case.' '
	250	rm -f .git/index AN &&
	251	cp .orig-A/AN AN &&
	252	echo extra >>AN &&
	253	git update-index --add AN &&
	254	read_tree_must_fail -m $tree_O $tree_A $tree_B
	255	'
	256
	257	test_expect_success '4 - must match and be up-to-date in !O && A && B && A!=B case.' '
	258	rm -f .git/index AA &&
	259	cp .orig-A/AA AA &&
	260	git update-index --add AA &&
	261	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
	262	check_result
	263	'
	264
	265	test_expect_success '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' '
	266	rm -f .git/index AA &&
	267	cp .orig-A/AA AA &&
	268	git update-index --add AA &&
	269	echo extra >>AA &&
	270	read_tree_must_fail -m $tree_O $tree_A $tree_B
	271	'
	272
	273	test_expect_success '4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' '
	274	rm -f .git/index AA &&
275	cp .orig-A/AA AA &&
276	echo extra >>AA &&
277	git update-index --add AA &&
278	read_tree_must_fail -m $tree_O $tree_A $tree_B
279	'
280
281	test_expect_success '5 - must match in !O && A && B && A==B case.' '
282	rm -f .git/index LL &&
283	cp .orig-A/LL LL &&
284	git update-index --add LL &&
285	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
286	check_result
287	'
288
289	test_expect_success '5 - must match in !O && A && B && A==B case.' '
290	rm -f .git/index LL &&
291	cp .orig-A/LL LL &&
292	git update-index --add LL &&
293	echo extra >>LL &&
294	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
295	check_result
296	'
297
298	test_expect_success '5 (fail) - must match A in !O && A && B && A==B case.' '
299	rm -f .git/index LL &&
300	cp .orig-A/LL LL &&
301	echo extra >>LL &&
302	git update-index --add LL &&
303	read_tree_must_fail -m $tree_O $tree_A $tree_B
304	'
305
306	test_expect_success '6 - must not exist in O && !A && !B case' '
307	rm -f .git/index DD &&
308	echo DD >DD &&
309	git update-index --add DD &&
310	read_tree_must_fail -m $tree_O $tree_A $tree_B
311	'
312
313	test_expect_success '7 - must not exist in O && !A && B && O!=B case' '
314	rm -f .git/index DM &&
315	cp .orig-B/DM DM &&
316	git update-index --add DM &&
317	read_tree_must_fail -m $tree_O $tree_A $tree_B
318	'
319
320	test_expect_success '8 - must not exist in O && !A && B && O==B case' '
321	rm -f .git/index DN &&
322	cp .orig-B/DN DN &&
323	git update-index --add DN &&
324	read_tree_must_fail -m $tree_O $tree_A $tree_B
325	'
326
327	test_expect_success '9 - must match and be up-to-date in O && A && !B && O!=A case' '
328	rm -f .git/index MD &&
329	cp .orig-A/MD MD &&
330	git update-index --add MD &&
331	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
332	check_result
333	'
334
335	test_expect_success '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' '
336	rm -f .git/index MD &&
337	cp .orig-A/MD MD &&
338	git update-index --add MD &&
339	echo extra >>MD &&
340	read_tree_must_fail -m $tree_O $tree_A $tree_B
341	'
342
343	test_expect_success '9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' '
344	rm -f .git/index MD &&
345	cp .orig-A/MD MD &&
346	echo extra >>MD &&
347	git update-index --add MD &&
348	read_tree_must_fail -m $tree_O $tree_A $tree_B
349	'
350
351	test_expect_success '10 - must match and be up-to-date in O && A && !B && O==A case' '
352	rm -f .git/index ND &&
353	cp .orig-A/ND ND &&
354	git update-index --add ND &&
355	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
356	check_result
357	'
358
359	test_expect_success '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' '
360	rm -f .git/index ND &&
361	cp .orig-A/ND ND &&
362	git update-index --add ND &&
363	echo extra >>ND &&
364	read_tree_must_fail -m $tree_O $tree_A $tree_B
365	'
366
367	test_expect_success '10 (fail) - must match and be up-to-date in O && A && !B && O==A case' '
368	rm -f .git/index ND &&
369	cp .orig-A/ND ND &&
370	echo extra >>ND &&
371	git update-index --add ND &&
372	read_tree_must_fail -m $tree_O $tree_A $tree_B
373	'
374
375	test_expect_success '11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' '
376	rm -f .git/index MM &&
377	cp .orig-A/MM MM &&
378	git update-index --add MM &&
379	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
380	check_result
381	'
382
383	test_expect_success '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' '
384	rm -f .git/index MM &&
385	cp .orig-A/MM MM &&
386	git update-index --add MM &&
387	echo extra >>MM &&
388	read_tree_must_fail -m $tree_O $tree_A $tree_B
389	'
390
391	test_expect_success '11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' '
392	rm -f .git/index MM &&
393	cp .orig-A/MM MM &&
394	echo extra >>MM &&
395	git update-index --add MM &&
396	read_tree_must_fail -m $tree_O $tree_A $tree_B
397	'
398
399	test_expect_success '12 - must match A in O && A && B && O!=A && A==B case' '
400	rm -f .git/index SS &&
401	cp .orig-A/SS SS &&
402	git update-index --add SS &&
403	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
404	check_result
405	'
406
407	test_expect_success '12 - must match A in O && A && B && O!=A && A==B case' '
408	rm -f .git/index SS &&
409	cp .orig-A/SS SS &&
410	git update-index --add SS &&
411	echo extra >>SS &&
412	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
413	check_result
414	'
415
416	test_expect_success '12 (fail) - must match A in O && A && B && O!=A && A==B case' '
417	rm -f .git/index SS &&
418	cp .orig-A/SS SS &&
419	echo extra >>SS &&
420	git update-index --add SS &&
421	read_tree_must_fail -m $tree_O $tree_A $tree_B
422	'
423
424	test_expect_success '13 - must match A in O && A && B && O!=A && O==B case' '
425	rm -f .git/index MN &&
426	cp .orig-A/MN MN &&
427	git update-index --add MN &&
428	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
429	check_result
430	'
431
432	test_expect_success '13 - must match A in O && A && B && O!=A && O==B case' '
433	rm -f .git/index MN &&
434	cp .orig-A/MN MN &&
435	git update-index --add MN &&
436	echo extra >>MN &&
437	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
438	check_result
439	'
440
441	test_expect_success '14 - must match and be up-to-date in O && A && B && O==A && O!=B case' '
442	rm -f .git/index NM &&
443	cp .orig-A/NM NM &&
444	git update-index --add NM &&
445	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
446	check_result
447	'
448
449	test_expect_success '14 - may match B in O && A && B && O==A && O!=B case' '
450	rm -f .git/index NM &&
451	cp .orig-B/NM NM &&
452	git update-index --add NM &&
453	echo extra >>NM &&
454	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
455	check_result
456	'
457
458	test_expect_success '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' '
459	rm -f .git/index NM &&
460	cp .orig-A/NM NM &&
461	git update-index --add NM &&
462	echo extra >>NM &&
463	read_tree_must_fail -m $tree_O $tree_A $tree_B
464	'
465
466	test_expect_success '14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' '
467	rm -f .git/index NM &&
468	cp .orig-A/NM NM &&
469	echo extra >>NM &&
470	git update-index --add NM &&
471	read_tree_must_fail -m $tree_O $tree_A $tree_B
472	'
473
474	test_expect_success '15 - must match A in O && A && B && O==A && O==B case' '
475	rm -f .git/index NN &&
476	cp .orig-A/NN NN &&
477	git update-index --add NN &&
478	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
479	check_result
480	'
481
482	test_expect_success '15 - must match A in O && A && B && O==A && O==B case' '
483	rm -f .git/index NN &&
484	cp .orig-A/NN NN &&
485	git update-index --add NN &&
486	echo extra >>NN &&
487	read_tree_must_succeed -m $tree_O $tree_A $tree_B &&
488	check_result
489	'
490
491	test_expect_success '15 (fail) - must match A in O && A && B && O==A && O==B case' '
492	rm -f .git/index NN &&
493	cp .orig-A/NN NN &&
494	echo extra >>NN &&
495	git update-index --add NN &&
496	read_tree_must_fail -m $tree_O $tree_A $tree_B
497	'
498
499	test_expect_success '16 - A matches in one and B matches in another.' '
500	rm -f .git/index F16 &&
501	echo F16 >F16 &&
502	git update-index --add F16 &&
503	tree0=$(git write-tree) &&
504	echo E16 >F16 &&
505	git update-index F16 &&
506	tree1=$(git write-tree) &&
507	read_tree_must_succeed -m $tree0 $tree1 $tree1 $tree0 &&
508	git ls-files --stage
509	'
4d3fe0c5	510
2ecd9050	511	test_done