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

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

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"

# #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
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
3e03aaf5	161	checked.
f225b218	162
3e03aaf5	163	"git-read-tree -m O A B"
f225b218 JH	164
	165	O A B result index requirements
	166	-------------------------------------------------------------------
	167	1 missing missing missing - must not exist.
	168	------------------------------------------------------------------
3e03aaf5	169	2 missing missing exists take B* must match B, if exists.
f225b218	170	------------------------------------------------------------------
3e03aaf5	171	3 missing exists missing take A* must match A, if exists.
f225b218 JH	172	------------------------------------------------------------------
	173	4 missing exists A!=B no merge must match A and be
	174	up-to-date, if exists.
	175	------------------------------------------------------------------
3e03aaf5	176	5 missing exists A==B take A must match A, if exists.
f225b218	177	------------------------------------------------------------------
3e03aaf5	178	6 exists missing missing remove must not exist.
f225b218 JH	179	------------------------------------------------------------------
	180	7 exists missing O!=B no merge must not exist.
	181	------------------------------------------------------------------
3e03aaf5	182	8 exists missing O==B remove must not exist.
f225b218 JH	183	------------------------------------------------------------------
	184	9 exists O!=A missing no merge must match A and be
	185	up-to-date, if exists.
	186	------------------------------------------------------------------
3e03aaf5	187	10 exists O==A missing remove ditto
f225b218 JH	188	------------------------------------------------------------------
	189	11 exists O!=A O!=B no merge must match A and be
	190	A!=B up-to-date, if exists.
	191	------------------------------------------------------------------
	192	12 exists O!=A O!=B take A must match A, if exists.
	193	A==B
	194	------------------------------------------------------------------
	195	13 exists O!=A O==B take A must match A, if exists.
	196	------------------------------------------------------------------
3e03aaf5	197	14 exists O==A O!=B take B if exists, must either (1)
f225b218 JH	198	match A and be up-to-date,
	199	or (2) match B.
	200	------------------------------------------------------------------
	201	15 exists O==A O==B take B must match A if exists.
4d3fe0c5 JH	202	------------------------------------------------------------------
	203	16 exists O==A O==B barf must match A if exists.
	204	multi in one in another
f225b218 JH	205	-------------------------------------------------------------------
f225b218 JH	206
3e03aaf5 JH	207	Note: we need to be careful in case 2 and 3. The tree A may contain
	208	DF (file) when tree B require DF to be a directory by having DF/DF
	209	(file).
f225b218 JH	210
	211	END_OF_CASE_TABLE
	212
	213	test_expect_failure \
	214	'1 - must not have an entry not in A.' \
	215	"rm -f .git/index XX &&
	216	echo XX >XX &&
215a7ad1	217	git-update-index --add XX &&
f225b218 JH	218	git-read-tree -m $tree_O $tree_A $tree_B"
f225b218 JH	219
32192e66 JH	220	test_expect_success \
	221	'2 - must match B in !O && !A && B case.' \
	222	"rm -f .git/index NA &&
	223	cp .orig-B/NA NA &&
215a7ad1	224	git-update-index --add NA &&
32192e66 JH	225	git-read-tree -m $tree_O $tree_A $tree_B"
	226
	227	test_expect_success \
	228	'2 - matching B alone is OK in !O && !A && B case.' \
f225b218 JH	229	"rm -f .git/index NA &&
f225b218 JH	230	cp .orig-B/NA NA &&
215a7ad1	231	git-update-index --add NA &&
32192e66	232	echo extra >>NA &&
f225b218 JH	233	git-read-tree -m $tree_O $tree_A $tree_B"
	234
	235	test_expect_success \
32192e66	236	'3 - must match A in !O && A && !B case.' \
f225b218 JH	237	"rm -f .git/index AN &&
f225b218 JH	238	cp .orig-A/AN AN &&
215a7ad1	239	git-update-index --add AN &&
f225b218 JH	240	git-read-tree -m $tree_O $tree_A $tree_B &&
	241	check_result"
	242
32192e66 JH	243	test_expect_success \
32192e66 JH	244	'3 - matching A alone is OK in !O && A && !B case.' \
f225b218 JH	245	"rm -f .git/index AN &&
f225b218 JH	246	cp .orig-A/AN AN &&
215a7ad1	247	git-update-index --add AN &&
f225b218 JH	248	echo extra >>AN &&
	249	git-read-tree -m $tree_O $tree_A $tree_B"
	250
	251	test_expect_failure \
32192e66	252	'3 (fail) - must match A in !O && A && !B case.' \
f225b218 JH	253	"rm -f .git/index AN &&
	254	cp .orig-A/AN AN &&
	255	echo extra >>AN &&
215a7ad1	256	git-update-index --add AN &&
f225b218 JH	257	git-read-tree -m $tree_O $tree_A $tree_B"
	258
	259	test_expect_success \
	260	'4 - must match and be up-to-date in !O && A && B && A!=B case.' \
	261	"rm -f .git/index AA &&
	262	cp .orig-A/AA AA &&
215a7ad1	263	git-update-index --add AA &&
f225b218 JH	264	git-read-tree -m $tree_O $tree_A $tree_B &&
	265	check_result"
	266
	267	test_expect_failure \
	268	'4 (fail) - must match and be up-to-date in !O && A && B && A!=B case.' \
	269	"rm -f .git/index AA &&
	270	cp .orig-A/AA AA &&
215a7ad1	271	git-update-index --add AA &&
f225b218 JH	272	echo extra >>AA &&
	273	git-read-tree -m $tree_O $tree_A $tree_B"
	274
	275	test_expect_failure \
	276	'4 (fail) - 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 &&
	279	echo extra >>AA &&
215a7ad1	280	git-update-index --add AA &&
f225b218 JH	281	git-read-tree -m $tree_O $tree_A $tree_B"
	282
	283	test_expect_success \
e7f9bc41	284	'5 - must match in !O && A && B && A==B case.' \
f225b218 JH	285	"rm -f .git/index LL &&
f225b218 JH	286	cp .orig-A/LL LL &&
215a7ad1	287	git-update-index --add LL &&
f225b218 JH	288	git-read-tree -m $tree_O $tree_A $tree_B &&
	289	check_result"
	290
e7f9bc41 JH	291	test_expect_success \
e7f9bc41 JH	292	'5 - must match in !O && A && B && A==B case.' \
f225b218 JH	293	"rm -f .git/index LL &&
f225b218 JH	294	cp .orig-A/LL LL &&
215a7ad1	295	git-update-index --add LL &&
f225b218	296	echo extra >>LL &&
e7f9bc41 JH	297	git-read-tree -m $tree_O $tree_A $tree_B &&
e7f9bc41 JH	298	check_result"
f225b218 JH	299
f225b218 JH	300	test_expect_failure \
e7f9bc41	301	'5 (fail) - must match A in !O && A && B && A==B case.' \
f225b218 JH	302	"rm -f .git/index LL &&
	303	cp .orig-A/LL LL &&
	304	echo extra >>LL &&
215a7ad1	305	git-update-index --add LL &&
f225b218 JH	306	git-read-tree -m $tree_O $tree_A $tree_B"
	307
	308	test_expect_failure \
	309	'6 - must not exist in O && !A && !B case' \
	310	"rm -f .git/index DD &&
	311	echo DD >DD
215a7ad1	312	git-update-index --add DD &&
f225b218 JH	313	git-read-tree -m $tree_O $tree_A $tree_B"
	314
	315	test_expect_failure \
	316	'7 - must not exist in O && !A && B && O!=B case' \
	317	"rm -f .git/index DM &&
	318	cp .orig-B/DM DM &&
215a7ad1	319	git-update-index --add DM &&
f225b218 JH	320	git-read-tree -m $tree_O $tree_A $tree_B"
	321
	322	test_expect_failure \
	323	'8 - must not exist in O && !A && B && O==B case' \
	324	"rm -f .git/index DN &&
	325	cp .orig-B/DN DN &&
215a7ad1	326	git-update-index --add DN &&
f225b218 JH	327	git-read-tree -m $tree_O $tree_A $tree_B"
	328
	329	test_expect_success \
	330	'9 - must match and be up-to-date in O && A && !B && O!=A case' \
	331	"rm -f .git/index MD &&
	332	cp .orig-A/MD MD &&
215a7ad1	333	git-update-index --add MD &&
f225b218 JH	334	git-read-tree -m $tree_O $tree_A $tree_B &&
	335	check_result"
	336
	337	test_expect_failure \
	338	'9 (fail) - must match and be up-to-date in O && A && !B && O!=A case' \
	339	"rm -f .git/index MD &&
	340	cp .orig-A/MD MD &&
215a7ad1	341	git-update-index --add MD &&
f225b218 JH	342	echo extra >>MD &&
	343	git-read-tree -m $tree_O $tree_A $tree_B"
	344
	345	test_expect_failure \
	346	'9 (fail) - 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 &&
	349	echo extra >>MD &&
215a7ad1	350	git-update-index --add MD &&
f225b218 JH	351	git-read-tree -m $tree_O $tree_A $tree_B"
	352
	353	test_expect_success \
	354	'10 - must match and be up-to-date in O && A && !B && O==A case' \
	355	"rm -f .git/index ND &&
	356	cp .orig-A/ND ND &&
215a7ad1	357	git-update-index --add ND &&
f225b218 JH	358	git-read-tree -m $tree_O $tree_A $tree_B &&
	359	check_result"
	360
	361	test_expect_failure \
	362	'10 (fail) - must match and be up-to-date in O && A && !B && O==A case' \
	363	"rm -f .git/index ND &&
	364	cp .orig-A/ND ND &&
215a7ad1	365	git-update-index --add ND &&
f225b218 JH	366	echo extra >>ND &&
	367	git-read-tree -m $tree_O $tree_A $tree_B"
	368
	369	test_expect_failure \
	370	'10 (fail) - 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 &&
	373	echo extra >>ND &&
215a7ad1	374	git-update-index --add ND &&
f225b218 JH	375	git-read-tree -m $tree_O $tree_A $tree_B"
	376
	377	test_expect_success \
	378	'11 - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
	379	"rm -f .git/index MM &&
	380	cp .orig-A/MM MM &&
215a7ad1	381	git-update-index --add MM &&
f225b218 JH	382	git-read-tree -m $tree_O $tree_A $tree_B &&
	383	check_result"
	384
	385	test_expect_failure \
	386	'11 (fail) - must match and be up-to-date in O && A && B && O!=A && O!=B && A!=B case' \
	387	"rm -f .git/index MM &&
	388	cp .orig-A/MM MM &&
215a7ad1	389	git-update-index --add MM &&
f225b218 JH	390	echo extra >>MM &&
	391	git-read-tree -m $tree_O $tree_A $tree_B"
	392
	393	test_expect_failure \
	394	'11 (fail) - 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 &&
	397	echo extra >>MM &&
215a7ad1	398	git-update-index --add MM &&
f225b218 JH	399	git-read-tree -m $tree_O $tree_A $tree_B"
	400
	401	test_expect_success \
	402	'12 - must match A in O && A && B && O!=A && A==B case' \
	403	"rm -f .git/index SS &&
	404	cp .orig-A/SS SS &&
215a7ad1	405	git-update-index --add SS &&
f225b218 JH	406	git-read-tree -m $tree_O $tree_A $tree_B &&
	407	check_result"
	408
	409	test_expect_success \
	410	'12 - must match A in O && A && B && O!=A && A==B case' \
	411	"rm -f .git/index SS &&
	412	cp .orig-A/SS SS &&
215a7ad1	413	git-update-index --add SS &&
f225b218 JH	414	echo extra >>SS &&
	415	git-read-tree -m $tree_O $tree_A $tree_B &&
	416	check_result"
	417
	418	test_expect_failure \
	419	'12 (fail) - must match A in O && A && B && O!=A && A==B case' \
	420	"rm -f .git/index SS &&
	421	cp .orig-A/SS SS &&
	422	echo extra >>SS &&
215a7ad1	423	git-update-index --add SS &&
f225b218 JH	424	git-read-tree -m $tree_O $tree_A $tree_B"
	425
	426	test_expect_success \
	427	'13 - must match A in O && A && B && O!=A && O==B case' \
	428	"rm -f .git/index MN &&
	429	cp .orig-A/MN MN &&
215a7ad1	430	git-update-index --add MN &&
f225b218 JH	431	git-read-tree -m $tree_O $tree_A $tree_B &&
	432	check_result"
	433
	434	test_expect_success \
	435	'13 - must match A in O && A && B && O!=A && O==B case' \
	436	"rm -f .git/index MN &&
	437	cp .orig-A/MN MN &&
215a7ad1	438	git-update-index --add MN &&
f225b218 JH	439	echo extra >>MN &&
	440	git-read-tree -m $tree_O $tree_A $tree_B &&
	441	check_result"
	442
	443	test_expect_success \
	444	'14 - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	445	"rm -f .git/index NM &&
	446	cp .orig-A/NM NM &&
215a7ad1	447	git-update-index --add NM &&
f225b218 JH	448	git-read-tree -m $tree_O $tree_A $tree_B &&
	449	check_result"
	450
036d51cc JH	451	test_expect_success \
	452	'14 - may match B in O && A && B && O==A && O!=B case' \
	453	"rm -f .git/index NM &&
	454	cp .orig-B/NM NM &&
215a7ad1	455	git-update-index --add NM &&
036d51cc JH	456	echo extra >>NM &&
	457	git-read-tree -m $tree_O $tree_A $tree_B &&
	458	check_result"
	459
f225b218 JH	460	test_expect_failure \
	461	'14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	462	"rm -f .git/index NM &&
	463	cp .orig-A/NM NM &&
215a7ad1	464	git-update-index --add NM &&
f225b218 JH	465	echo extra >>NM &&
	466	git-read-tree -m $tree_O $tree_A $tree_B"
	467
	468	test_expect_failure \
	469	'14 (fail) - must match and be up-to-date in O && A && B && O==A && O!=B case' \
	470	"rm -f .git/index NM &&
	471	cp .orig-A/NM NM &&
	472	echo extra >>NM &&
215a7ad1	473	git-update-index --add NM &&
f225b218 JH	474	git-read-tree -m $tree_O $tree_A $tree_B"
	475
	476	test_expect_success \
	477	'15 - must match A in O && A && B && O==A && O==B case' \
	478	"rm -f .git/index NN &&
	479	cp .orig-A/NN NN &&
215a7ad1	480	git-update-index --add NN &&
f225b218 JH	481	git-read-tree -m $tree_O $tree_A $tree_B &&
	482	check_result"
	483
	484	test_expect_success \
	485	'15 - must match A in O && A && B && O==A && O==B case' \
	486	"rm -f .git/index NN &&
	487	cp .orig-A/NN NN &&
215a7ad1	488	git-update-index --add NN &&
f225b218 JH	489	echo extra >>NN &&
	490	git-read-tree -m $tree_O $tree_A $tree_B &&
	491	check_result"
	492
	493	test_expect_failure \
	494	'15 (fail) - must match A in O && A && B && O==A && O==B case' \
	495	"rm -f .git/index NN &&
	496	cp .orig-A/NN NN &&
	497	echo extra >>NN &&
215a7ad1	498	git-update-index --add NN &&
f225b218	499	git-read-tree -m $tree_O $tree_A $tree_B"
2ecd9050	500
4d3fe0c5 JH	501	# #16
	502	test_expect_success \
	503	'16 - A matches in one and B matches in another.' \
	504	'rm -f .git/index F16 &&
	505	echo F16 >F16 &&
	506	git-update-index --add F16 &&
	507	tree0=`git-write-tree` &&
	508	echo E16 >F16 &&
	509	git-update-index F16 &&
	510	tree1=`git-write-tree` &&
	511	git-read-tree -m $tree0 $tree1 $tree1 $tree0 &&
	512	git-ls-files --stage'
	513
2ecd9050	514	test_done