[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
. ../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

_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"

check_result () {
    git-ls-files --stage | sed -e 's/ '"$_x40"' / X /' >current &&
    diff -u 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 &&
     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 \
    '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.  The table also lists alternative semantics which is not
currently implemented.

"git-diff-tree -m O A B"

     O       A       B         result      index requirements
-------------------------------------------------------------------
  1  missing missing missing   -           must not exist.
 ------------------------------------------------------------------
  2  missing missing exists    no merge    must not exist.
                               ------------------------------------
    (ALT)                      take B*     must match B, if exists.
 ------------------------------------------------------------------
  3  missing exists  missing   no merge    must match A and be
                                           up-to-date, if exists.
                               ------------------------------------
    (ALT)                      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      no merge    must match A and be
                                           up-to-date, if exists.
                               ------------------------------------
    (ALT)                      take A      must match A, if exists.
 ------------------------------------------------------------------
  6  exists  missing missing   no merge    must not exist.
                               ------------------------------------
    (ALT)                      remove      must not exist.
 ------------------------------------------------------------------
  7  exists  missing O!=B      no merge    must not exist.
 ------------------------------------------------------------------
  8  exists  missing O==B      no merge    must not exist.
                               ------------------------------------
    (ALT)                      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 and be
                                           up-to-date, if exists.
                               ------------------------------------
    (ALT)                      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      must match A and be
                                           be up-to-date, if exists.
                               ------------------------------------
    (ALT)                      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.
-------------------------------------------------------------------

Note: if we want to implement 2ALT and 3ALT we need to be careful.
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"

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 &&
     git-read-tree -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 &&
     git-read-tree -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 &&
     git-read-tree -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 &&
     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"

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 &&
     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 \
    '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 \
    '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"

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 &&
     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 \
    '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 \
    '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"

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_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"

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 \
    '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"

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 \
    '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"

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 \
    '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"

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
63713028	75	. ../lib-read-tree-m-3way.sh
2ecd9050 JH	76
2ecd9050 JH	77	################################################################
32192e66 JH	78	# Trivial "majority when 3 stages exist" merge plus #2ALT, #3ALT
32192e66 JH	79	# and #5ALT trivial merges.
2ecd9050	80
2ecd9050	81	cat >expected <<\EOF
2eab945e JH	82	100644 X 2 AA
2eab945e JH	83	100644 X 3 AA
32192e66	84	100644 X 0 AN
2eab945e JH	85	100644 X 1 DD
	86	100644 X 3 DF
	87	100644 X 2 DF/DF
	88	100644 X 1 DM
	89	100644 X 3 DM
	90	100644 X 1 DN
	91	100644 X 3 DN
e7f9bc41	92	100644 X 0 LL
2eab945e JH	93	100644 X 1 MD
	94	100644 X 2 MD
	95	100644 X 1 MM
	96	100644 X 2 MM
	97	100644 X 3 MM
	98	100644 X 0 MN
32192e66	99	100644 X 0 NA
2eab945e JH	100	100644 X 1 ND
	101	100644 X 2 ND
	102	100644 X 0 NM
	103	100644 X 0 NN
	104	100644 X 0 SS
	105	100644 X 1 TT
	106	100644 X 2 TT
	107	100644 X 3 TT
	108	100644 X 2 Z/AA
	109	100644 X 3 Z/AA
32192e66	110	100644 X 0 Z/AN
2eab945e JH	111	100644 X 1 Z/DD
	112	100644 X 1 Z/DM
	113	100644 X 3 Z/DM
	114	100644 X 1 Z/DN
	115	100644 X 3 Z/DN
	116	100644 X 1 Z/MD
	117	100644 X 2 Z/MD
	118	100644 X 1 Z/MM
	119	100644 X 2 Z/MM
	120	100644 X 3 Z/MM
	121	100644 X 0 Z/MN
32192e66	122	100644 X 0 Z/NA
2eab945e JH	123	100644 X 1 Z/ND
	124	100644 X 2 Z/ND
	125	100644 X 0 Z/NM
	126	100644 X 0 Z/NN
2ecd9050 JH	127	EOF
2ecd9050 JH	128
7d95ee93 JH	129	_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
	130	_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
	131
f225b218 JH	132	check_result () {
	133	git-ls-files --stage \| sed -e 's/ '"$_x40"' / X /' >current &&
	134	diff -u expected current
	135	}
7d95ee93 JH	136
	137	# This is done on an empty work directory, which is the normal
	138	# merge person behaviour.
	139	test_expect_success \
	140	'3-way merge with git-read-tree -m, empty cache' \
	141	"rm -fr [NDMALTS][NDMALTSF] Z &&
	142	rm .git/index &&
	143	git-read-tree -m $tree_O $tree_A $tree_B &&
f225b218	144	check_result"
7d95ee93 JH	145
	146	# This starts out with the first head, which is the normal
	147	# patch submitter behaviour.
2ecd9050	148	test_expect_success \
7d95ee93	149	'3-way merge with git-read-tree -m, match H' \
f225b218 JH	150	"rm -fr [NDMALTS][NDMALTSF] Z &&
	151	rm .git/index &&
	152	git-read-tree $tree_A &&
215a7ad1	153	git-checkout-index -f -u -a &&
7d95ee93	154	git-read-tree -m $tree_O $tree_A $tree_B &&
f225b218 JH	155	check_result"
	156
	157	: <<\END_OF_CASE_TABLE
	158
	159	We have so far tested only empty index and clean-and-matching-A index
	160	case which are trivial. Make sure index requirements are also
	161	checked. The table also lists alternative semantics which is not
	162	currently implemented.
	163
	164	"git-diff-tree -m O A B"
	165
	166	O A B result index requirements
	167	-------------------------------------------------------------------
	168	1 missing missing missing - must not exist.
	169	------------------------------------------------------------------
	170	2 missing missing exists no merge must not exist.
	171	------------------------------------
	172	(ALT) take B* must match B, if exists.
	173	------------------------------------------------------------------
	174	3 missing exists missing no merge must match A and be
	175	up-to-date, if exists.
	176	------------------------------------
	177	(ALT) take A* must match A, if exists.
	178	------------------------------------------------------------------
	179	4 missing exists A!=B no merge must match A and be
	180	up-to-date, if exists.
	181	------------------------------------------------------------------
	182	5 missing exists A==B no merge must match A and be
	183	up-to-date, if exists.
	184	------------------------------------
	185	(ALT) take A must match A, if exists.
	186	------------------------------------------------------------------
	187	6 exists missing missing no merge must not exist.
	188	------------------------------------
	189	(ALT) remove must not exist.
	190	------------------------------------------------------------------
	191	7 exists missing O!=B no merge must not exist.
	192	------------------------------------------------------------------
	193	8 exists missing O==B no merge must not exist.
	194	------------------------------------
	195	(ALT) remove must not exist.
	196	------------------------------------------------------------------
	197	9 exists O!=A missing no merge must match A and be
	198	up-to-date, if exists.
	199	------------------------------------------------------------------
	200	10 exists O==A missing no merge must match A and be
	201	up-to-date, if exists.
	202	------------------------------------
	203	(ALT) remove ditto
	204	------------------------------------------------------------------
	205	11 exists O!=A O!=B no merge must match A and be
	206	A!=B up-to-date, if exists.
	207	------------------------------------------------------------------
	208	12 exists O!=A O!=B take A must match A, if exists.
	209	A==B
	210	------------------------------------------------------------------
	211	13 exists O!=A O==B take A must match A, if exists.
	212	------------------------------------------------------------------
	213	14 exists O==A O!=B take B must match A and be
	214	be up-to-date, if exists.
	215	------------------------------------
	216	(ALT) take B if exists, must either (1)
	217	match A and be up-to-date,
	218	or (2) match B.
219	------------------------------------------------------------------
220	15 exists O==A O==B take B must match A if exists.
221	-------------------------------------------------------------------
222
223	Note: if we want to implement 2ALT and 3ALT we need to be careful.
224	The tree A may contain DF (file) when tree B require DF to be a
225	directory by having DF/DF (file).
226
227	END_OF_CASE_TABLE
228
229	test_expect_failure \
230	'1 - must not have an entry not in A.' \
231	"rm -f .git/index XX &&
232	echo XX >XX &&
215a7ad1	233	git-update-index --add XX &&
f225b218 JH	234	git-read-tree -m $tree_O $tree_A $tree_B"
f225b218 JH	235
32192e66 JH	236	test_expect_success \
	237	'2 - must match B in !O && !A && B case.' \
	238	"rm -f .git/index NA &&
	239	cp .orig-B/NA NA &&
215a7ad1	240	git-update-index --add NA &&
32192e66 JH	241	git-read-tree -m $tree_O $tree_A $tree_B"
	242
	243	test_expect_success \
	244	'2 - matching B alone is OK in !O && !A && B case.' \
f225b218 JH	245	"rm -f .git/index NA &&
f225b218 JH	246	cp .orig-B/NA NA &&
215a7ad1	247	git-update-index --add NA &&
32192e66	248	echo extra >>NA &&
f225b218 JH	249	git-read-tree -m $tree_O $tree_A $tree_B"
	250
	251	test_expect_success \
32192e66	252	'3 - must match A in !O && A && !B case.' \
f225b218 JH	253	"rm -f .git/index AN &&
f225b218 JH	254	cp .orig-A/AN AN &&
215a7ad1	255	git-update-index --add AN &&
f225b218 JH	256	git-read-tree -m $tree_O $tree_A $tree_B &&
	257	check_result"
	258
32192e66 JH	259	test_expect_success \
32192e66 JH	260	'3 - matching A alone is OK in !O && A && !B case.' \
f225b218 JH	261	"rm -f .git/index AN &&
f225b218 JH	262	cp .orig-A/AN AN &&
215a7ad1	263	git-update-index --add AN &&
f225b218 JH	264	echo extra >>AN &&
	265	git-read-tree -m $tree_O $tree_A $tree_B"
	266
	267	test_expect_failure \
32192e66	268	'3 (fail) - must match A in !O && A && !B case.' \
f225b218 JH	269	"rm -f .git/index AN &&
	270	cp .orig-A/AN AN &&
	271	echo extra >>AN &&
215a7ad1	272	git-update-index --add AN &&
f225b218 JH	273	git-read-tree -m $tree_O $tree_A $tree_B"
	274
	275	test_expect_success \
	276	'4 - must match and be up-to-date in !O && A && B && A!=B case.' \
	277	"rm -f .git/index AA &&
	278	cp .orig-A/AA AA &&
215a7ad1	279	git-update-index --add AA &&
f225b218 JH	280	git-read-tree -m $tree_O $tree_A $tree_B &&
	281	check_result"
	282
	283	test_expect_failure \
	284	'4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
	285	"rm -f .git/index AA &&
	286	cp .orig-A/AA AA &&
215a7ad1	287	git-update-index --add AA &&
f225b218 JH	288	echo extra >>AA &&
	289	git-read-tree -m $tree_O $tree_A $tree_B"
	290
	291	test_expect_failure \
	292	'4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
	293	"rm -f .git/index AA &&
	294	cp .orig-A/AA AA &&
	295	echo extra >>AA &&
215a7ad1	296	git-update-index --add AA &&
f225b218 JH	297	git-read-tree -m $tree_O $tree_A $tree_B"
	298
	299	test_expect_success \
e7f9bc41	300	'5 - must match in !O && A && B && A==B case.' \
f225b218 JH	301	"rm -f .git/index LL &&
f225b218 JH	302	cp .orig-A/LL LL &&
215a7ad1	303	git-update-index --add LL &&
f225b218 JH	304	git-read-tree -m $tree_O $tree_A $tree_B &&
	305	check_result"
	306
e7f9bc41 JH	307	test_expect_success \
e7f9bc41 JH	308	'5 - must match in !O && A && B && A==B case.' \
f225b218 JH	309	"rm -f .git/index LL &&
f225b218 JH	310	cp .orig-A/LL LL &&
215a7ad1	311	git-update-index --add LL &&
f225b218	312	echo extra >>LL &&
e7f9bc41 JH	313	git-read-tree -m $tree_O $tree_A $tree_B &&
e7f9bc41 JH	314	check_result"
f225b218 JH	315
f225b218 JH	316	test_expect_failure \
e7f9bc41	317	'5 (fail) - must match A in !O && A && B && A==B case.' \
f225b218 JH	318	"rm -f .git/index LL &&
	319	cp .orig-A/LL LL &&
	320	echo extra >>LL &&
215a7ad1	321	git-update-index --add LL &&
f225b218 JH	322	git-read-tree -m $tree_O $tree_A $tree_B"
	323
	324	test_expect_failure \
	325	'6 - must not exist in O && !A && !B case' \
	326	"rm -f .git/index DD &&
	327	echo DD >DD
215a7ad1	328	git-update-index --add DD &&
f225b218 JH	329	git-read-tree -m $tree_O $tree_A $tree_B"
	330
	331	test_expect_failure \
	332	'7 - must not exist in O && !A && B && O!=B case' \
	333	"rm -f .git/index DM &&
	334	cp .orig-B/DM DM &&
215a7ad1	335	git-update-index --add DM &&
f225b218 JH	336	git-read-tree -m $tree_O $tree_A $tree_B"
	337
	338	test_expect_failure \
	339	'8 - must not exist in O && !A && B && O==B case' \
	340	"rm -f .git/index DN &&
	341	cp .orig-B/DN DN &&
215a7ad1	342	git-update-index --add DN &&
f225b218 JH	343	git-read-tree -m $tree_O $tree_A $tree_B"
	344
	345	test_expect_success \
	346	'9 - must match and be up-to-date in O && A && !B && O!=A case' \
	347	"rm -f .git/index MD &&
	348	cp .orig-A/MD MD &&
215a7ad1	349	git-update-index --add MD &&
f225b218 JH	350	git-read-tree -m $tree_O $tree_A $tree_B &&
	351	check_result"
	352
	353	test_expect_failure \
	354	'9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
	355	"rm -f .git/index MD &&
	356	cp .orig-A/MD MD &&
215a7ad1	357	git-update-index --add MD &&
f225b218 JH	358	echo extra >>MD &&
	359	git-read-tree -m $tree_O $tree_A $tree_B"
	360
	361	test_expect_failure \
	362	'9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
	363	"rm -f .git/index MD &&
	364	cp .orig-A/MD MD &&
	365	echo extra >>MD &&
215a7ad1	366	git-update-index --add MD &&
f225b218 JH	367	git-read-tree -m $tree_O $tree_A $tree_B"
	368
	369	test_expect_success \
	370	'10 - must match and be up-to-date in O && A && !B && O==A case' \
	371	"rm -f .git/index ND &&
	372	cp .orig-A/ND ND &&
215a7ad1	373	git-update-index --add ND &&
f225b218 JH	374	git-read-tree -m $tree_O $tree_A $tree_B &&
	375	check_result"
	376
	377	test_expect_failure \
	378	'10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
	379	"rm -f .git/index ND &&
	380	cp .orig-A/ND ND &&
215a7ad1	381	git-update-index --add ND &&
f225b218 JH	382	echo extra >>ND &&
	383	git-read-tree -m $tree_O $tree_A $tree_B"
	384
	385	test_expect_failure \
	386	'10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
	387	"rm -f .git/index ND &&
	388	cp .orig-A/ND ND &&
	389	echo extra >>ND &&
215a7ad1	390	git-update-index --add ND &&
f225b218 JH	391	git-read-tree -m $tree_O $tree_A $tree_B"
	392
	393	test_expect_success \
	394	'11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
	395	"rm -f .git/index MM &&
	396	cp .orig-A/MM MM &&
215a7ad1	397	git-update-index --add MM &&
f225b218 JH	398	git-read-tree -m $tree_O $tree_A $tree_B &&
	399	check_result"
	400
	401	test_expect_failure \
	402	'11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
	403	"rm -f .git/index MM &&
	404	cp .orig-A/MM MM &&
215a7ad1	405	git-update-index --add MM &&
f225b218 JH	406	echo extra >>MM &&
	407	git-read-tree -m $tree_O $tree_A $tree_B"
	408
	409	test_expect_failure \
	410	'11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
	411	"rm -f .git/index MM &&
	412	cp .orig-A/MM MM &&
	413	echo extra >>MM &&
215a7ad1	414	git-update-index --add MM &&
f225b218 JH	415	git-read-tree -m $tree_O $tree_A $tree_B"
	416
	417	test_expect_success \
	418	'12 - must match A in O && A && B && O!=A && A==B case' \
	419	"rm -f .git/index SS &&
	420	cp .orig-A/SS SS &&
215a7ad1	421	git-update-index --add SS &&
f225b218 JH	422	git-read-tree -m $tree_O $tree_A $tree_B &&
	423	check_result"
	424
	425	test_expect_success \
	426	'12 - must match A in O && A && B && O!=A && A==B case' \
	427	"rm -f .git/index SS &&
	428	cp .orig-A/SS SS &&
215a7ad1	429	git-update-index --add SS &&
f225b218 JH	430	echo extra >>SS &&
	431	git-read-tree -m $tree_O $tree_A $tree_B &&
	432	check_result"
	433
	434	test_expect_failure \
	435	'12 (fail) - must match A in O && A && B && O!=A && A==B case' \
	436	"rm -f .git/index SS &&
	437	cp .orig-A/SS SS &&
	438	echo extra >>SS &&
215a7ad1	439	git-update-index --add SS &&
f225b218 JH	440	git-read-tree -m $tree_O $tree_A $tree_B"
	441
	442	test_expect_success \
	443	'13 - must match A in O && A && B && O!=A && O==B case' \
	444	"rm -f .git/index MN &&
	445	cp .orig-A/MN MN &&
215a7ad1	446	git-update-index --add MN &&
f225b218 JH	447	git-read-tree -m $tree_O $tree_A $tree_B &&
	448	check_result"
	449
	450	test_expect_success \
	451	'13 - must match A in O && A && B && O!=A && O==B case' \
	452	"rm -f .git/index MN &&
	453	cp .orig-A/MN MN &&
215a7ad1	454	git-update-index --add MN &&
f225b218 JH	455	echo extra >>MN &&
	456	git-read-tree -m $tree_O $tree_A $tree_B &&
	457	check_result"
	458
	459	test_expect_success \
	460	'14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	461	"rm -f .git/index NM &&
	462	cp .orig-A/NM NM &&
215a7ad1	463	git-update-index --add NM &&
f225b218 JH	464	git-read-tree -m $tree_O $tree_A $tree_B &&
	465	check_result"
	466
036d51cc JH	467	test_expect_success \
	468	'14 - may match B in O && A && B && O==A && O!=B case' \
	469	"rm -f .git/index NM &&
	470	cp .orig-B/NM NM &&
215a7ad1	471	git-update-index --add NM &&
036d51cc JH	472	echo extra >>NM &&
	473	git-read-tree -m $tree_O $tree_A $tree_B &&
	474	check_result"
	475
f225b218 JH	476	test_expect_failure \
	477	'14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	478	"rm -f .git/index NM &&
	479	cp .orig-A/NM NM &&
215a7ad1	480	git-update-index --add NM &&
f225b218 JH	481	echo extra >>NM &&
	482	git-read-tree -m $tree_O $tree_A $tree_B"
	483
	484	test_expect_failure \
	485	'14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	486	"rm -f .git/index NM &&
	487	cp .orig-A/NM NM &&
	488	echo extra >>NM &&
215a7ad1	489	git-update-index --add NM &&
f225b218 JH	490	git-read-tree -m $tree_O $tree_A $tree_B"
	491
	492	test_expect_success \
	493	'15 - must match A in O && A && B && O==A && O==B case' \
	494	"rm -f .git/index NN &&
	495	cp .orig-A/NN NN &&
215a7ad1	496	git-update-index --add NN &&
f225b218 JH	497	git-read-tree -m $tree_O $tree_A $tree_B &&
	498	check_result"
	499
	500	test_expect_success \
	501	'15 - must match A in O && A && B && O==A && O==B case' \
	502	"rm -f .git/index NN &&
	503	cp .orig-A/NN NN &&
215a7ad1	504	git-update-index --add NN &&
f225b218 JH	505	echo extra >>NN &&
	506	git-read-tree -m $tree_O $tree_A $tree_B &&
	507	check_result"
	508
	509	test_expect_failure \
	510	'15 (fail) - must match A in O && A && B && O==A && O==B case' \
	511	"rm -f .git/index NN &&
	512	cp .orig-A/NN NN &&
	513	echo extra >>NN &&
215a7ad1	514	git-update-index --add NN &&
f225b218	515	git-read-tree -m $tree_O $tree_A $tree_B"
2ecd9050 JH	516
2ecd9050 JH	517	test_done