[thirdparty/git.git] / t / t1001-read-tree-m-2way.sh

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

test_description='Two way merge with read-tree -m $H $M

This test tries two-way merge (aka fast forward with carry forward).

There is the head (called H) and another commit (called M), which is
simply ahead of H.  The index and the work tree contains a state that
is derived from H, but may also have local changes.  This test checks
all the combinations described in the two-tree merge "carry forward"
rules, found in <Documentation/git-rev-tree.txt>.

In the test, these paths are used:
        bozbar  - in H, stays in M, modified from bozbar to gnusto
        frotz   - not in H added in M
        nitfol  - in H, stays in M unmodified
        rezrov  - in H, deleted in M
        yomin   - not in H nor M
'
. ./test-lib.sh

read_tree_twoway () {
    git-read-tree -m "$1" "$2" && git-ls-files --stage
}

_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"
compare_change () {
	sed -n >current \
	    -e '/^--- /d; /^+++ /d; /^@@ /d;' \
	    -e 's/^\([-+][0-7][0-7][0-7][0-7][0-7][0-7]\) '"$_x40"' /\1 X /p' \
	    "$1"
	diff -u expected current
}

check_cache_at () {
	clean_if_empty=`git-diff-files "$1"`
	case "$clean_if_empty" in
	'')  echo "$1: clean" ;;
	?*)  echo "$1: dirty" ;;
	esac
	case "$2,$clean_if_empty" in
	clean,)		:     ;;
	clean,?*)	false ;;
	dirty,)		false ;;
	dirty,?*)	:     ;;
	esac
}

cat >bozbar-old <<\EOF
This is a sample file used in two-way fast forward merge
tests.  Its second line ends with a magic word bozbar
which will be modified by the merged head to gnusto.
It has some extra lines so that external tools can
successfully merge independent changes made to later
lines (such as this one), avoiding line conflicts.
EOF

sed -e 's/bozbar/gnusto (earlier bozbar)/' bozbar-old >bozbar-new

test_expect_success \
    setup \
    'echo frotz >frotz &&
     echo nitfol >nitfol &&
     cat bozbar-old >bozbar &&
     echo rezrov >rezrov &&
     echo yomin >yomin &&
     git-update-cache --add nitfol bozbar rezrov &&
     treeH=`git-write-tree` &&
     echo treeH $treeH &&
     git-ls-tree $treeH &&

     cat bozbar-new >bozbar &&
     git-update-cache --add frotz bozbar --force-remove rezrov &&
     git-ls-files --stage >M.out &&
     treeM=`git-write-tree` &&
     echo treeM $treeM &&
     git-ls-tree $treeM &&
     git-diff-tree $treeH $treeM'

test_expect_success \
    '1, 2, 3 - no carry forward' \
    'rm -f .git/index &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >1-3.out &&
     diff -u M.out 1-3.out &&
     check_cache_at bozbar dirty &&
     check_cache_at frotz dirty &&
     check_cache_at nitfol dirty'

echo '+100644 X 0	yomin' >expected

test_expect_success \
    '4 - carry forward local addition.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     git-update-cache --add yomin &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >4.out || return 1
     diff -u M.out 4.out >4diff.out
     compare_change 4diff.out expected &&
     check_cache_at yomin clean'

test_expect_success \
    '5 - carry forward local addition.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo yomin >yomin &&
     git-update-cache --add yomin &&
     echo yomin yomin >yomin &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >5.out || return 1
     diff -u M.out 5.out >5diff.out
     compare_change 5diff.out expected &&
     check_cache_at yomin dirty'

test_expect_success \
    '6 - local addition already has the same.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     git-update-cache --add frotz &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >6.out &&
     diff -u M.out 6.out &&
     check_cache_at frotz clean'

test_expect_success \
    '7 - local addition already has the same.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo frotz >frotz &&
     git-update-cache --add frotz &&
     echo frotz frotz >frotz &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >7.out &&
     diff -u M.out 7.out &&
     check_cache_at frotz dirty'

test_expect_success \
    '8 - conflicting addition.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo frotz frotz >frotz &&
     git-update-cache --add frotz &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '9 - conflicting addition.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo frotz frotz >frotz &&
     git-update-cache --add frotz &&
     echo frotz >frotz &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '10 - path removed.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo rezrov >rezrov &&
     git-update-cache --add rezrov &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >10.out &&
     diff -u M.out 10.out'

test_expect_success \
    '11 - dirty path removed.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo rezrov >rezrov &&
     git-update-cache --add rezrov &&
     echo rezrov rezrov >rezrov &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '12 - unmatching local changes being removed.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo rezrov rezrov >rezrov &&
     git-update-cache --add rezrov &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '13 - unmatching local changes being removed.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo rezrov rezrov >rezrov &&
     git-update-cache --add rezrov &&
     echo rezrov >rezrov &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

cat >expected <<EOF
-100644 X 0	nitfol
+100644 X 0	nitfol
EOF

test_expect_success \
    '14 - unchanged in two heads.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo nitfol nitfol >nitfol &&
     git-update-cache --add nitfol &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >14.out || return 1
     diff -u M.out 14.out >14diff.out
     compare_change 14diff.out expected &&
     check_cache_at nitfol clean'

test_expect_success \
    '15 - unchanged in two heads.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo nitfol nitfol >nitfol &&
     git-update-cache --add nitfol &&
     echo nitfol nitfol nitfol >nitfol &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >15.out || return 1
     diff -u M.out 15.out >15diff.out
     compare_change 15diff.out expected &&
     check_cache_at nitfol dirty'

test_expect_success \
    '16 - conflicting local change.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo bozbar bozbar >bozbar &&
     git-update-cache --add bozbar &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '17 - conflicting local change.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     echo bozbar bozbar >bozbar &&
     git-update-cache --add bozbar &&
     echo bozbar bozbar bozbar >bozbar &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

test_expect_success \
    '18 - local change already having a good result.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     cat bozbar-new >bozbar &&
     git-update-cache --add bozbar &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >18.out &&
     diff -u M.out 18.out &&
     check_cache_at bozbar clean'

test_expect_success \
    '19 - local change already having a good result, further modified.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     cat bozbar-new >bozbar &&
     git-update-cache --add bozbar &&
     echo gnusto gnusto >bozbar &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >19.out &&
     diff -u M.out 19.out &&
     check_cache_at bozbar dirty'

test_expect_success \
    '20 - no local change, use new tree.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     cat bozbar-old >bozbar &&
     git-update-cache --add bozbar &&
     read_tree_twoway $treeH $treeM &&
     git-ls-files --stage >20.out &&
     diff -u M.out 20.out &&
     check_cache_at bozbar dirty'

test_expect_success \
    '21 - no local change, dirty cache.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     cat bozbar-old >bozbar &&
     git-update-cache --add bozbar &&
     echo gnusto gnusto >bozbar &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

# This fails with straight two-way fast forward.
test_expect_success \
    '22 - local change cache updated.' \
    'rm -f .git/index &&
     git-read-tree $treeH &&
     git-checkout-cache -u -f -q -a &&
     sed -e "s/such as/SUCH AS/" bozbar-old >bozbar &&
     git-update-cache --add bozbar &&
     if read_tree_twoway $treeH $treeM; then false; else :; fi'

# Also make sure we did not break DF vs DF/DF case.
test_expect_success \
    'DF vs DF/DF case setup.' \
    'rm -f .git/index &&
     echo DF >DF &&
     git-update-cache --add DF &&
     treeDF=`git-write-tree` &&
     echo treeDF $treeDF &&
     git-ls-tree $treeDF &&

     rm -f DF &&
     mkdir DF &&
     echo DF/DF >DF/DF &&
     git-update-cache --add --remove DF DF/DF &&
     treeDFDF=`git-write-tree` &&
     echo treeDFDF $treeDFDF &&
     git-ls-tree $treeDFDF &&
     git-ls-files --stage >DFDF.out'

test_expect_success \
    'DF vs DF/DF case test.' \
    'rm -f .git/index &&
     rm -fr DF &&
     echo DF >DF &&
     git-update-cache --add DF &&
     read_tree_twoway $treeDF $treeDFDF &&
     git-ls-files --stage >DFDFcheck.out &&
     diff -u DFDF.out DFDFcheck.out &&
     check_cache_at DF/DF dirty &&
     :'

test_done
Commit	Line	Data
c8596009 JH	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2005 Junio C Hamano
	4	#
	5
	6	test_description='Two way merge with read-tree -m $H $M
	7
	8	This test tries two-way merge (aka fast forward with carry forward).
	9
	10	There is the head (called H) and another commit (called M), which is
	11	simply ahead of H. The index and the work tree contains a state that
	12	is derived from H, but may also have local changes. This test checks
	13	all the combinations described in the two-tree merge "carry forward"
	14	rules, found in <Documentation/git-rev-tree.txt>.
	15
	16	In the test, these paths are used:
	17	bozbar - in H, stays in M, modified from bozbar to gnusto
	18	frotz - not in H added in M
	19	nitfol - in H, stays in M unmodified
	20	rezrov - in H, deleted in M
	21	yomin - not in H nor M
	22	'
	23	. ./test-lib.sh
	24
76bc82ca JH	25	read_tree_twoway () {
	26	git-read-tree -m "$1" "$2" && git-ls-files --stage
	27	}
	28
c8596009 JH	29	_x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
	30	_x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
	31	compare_change () {
76bc82ca	32	sed -n >current \
c8596009	33	-e '/^--- /d; /^+++ /d; /^@@ /d;' \
76bc82ca JH	34	-e 's/^\([-+][0-7][0-7][0-7][0-7][0-7][0-7]\) '"$_x40"' /\1 X /p' \
76bc82ca JH	35	"$1"
c8596009 JH	36	diff -u expected current
	37	}
	38
	39	check_cache_at () {
	40	clean_if_empty=`git-diff-files "$1"`
	41	case "$clean_if_empty" in
	42	'') echo "$1: clean" ;;
	43	?*) echo "$1: dirty" ;;
	44	esac
	45	case "$2,$clean_if_empty" in
	46	clean,) : ;;
	47	clean,?*) false ;;
	48	dirty,) false ;;
	49	dirty,?*) : ;;
	50	esac
	51	}
	52
1abb3f14 JH	53	cat >bozbar-old <<\EOF
	54	This is a sample file used in two-way fast forward merge
	55	tests. Its second line ends with a magic word bozbar
	56	which will be modified by the merged head to gnusto.
	57	It has some extra lines so that external tools can
	58	successfully merge independent changes made to later
	59	lines (such as this one), avoiding line conflicts.
	60	EOF
	61
	62	sed -e 's/bozbar/gnusto (earlier bozbar)/' bozbar-old >bozbar-new
	63
c8596009 JH	64	test_expect_success \
	65	setup \
	66	'echo frotz >frotz &&
	67	echo nitfol >nitfol &&
1abb3f14	68	cat bozbar-old >bozbar &&
c8596009 JH	69	echo rezrov >rezrov &&
	70	echo yomin >yomin &&
	71	git-update-cache --add nitfol bozbar rezrov &&
	72	treeH=`git-write-tree` &&
	73	echo treeH $treeH &&
	74	git-ls-tree $treeH &&
	75
1abb3f14	76	cat bozbar-new >bozbar &&
c8596009 JH	77	git-update-cache --add frotz bozbar --force-remove rezrov &&
	78	git-ls-files --stage >M.out &&
	79	treeM=`git-write-tree` &&
	80	echo treeM $treeM &&
	81	git-ls-tree $treeM &&
	82	git-diff-tree $treeH $treeM'
	83
	84	test_expect_success \
	85	'1, 2, 3 - no carry forward' \
	86	'rm -f .git/index &&
76bc82ca	87	read_tree_twoway $treeH $treeM &&
c8596009	88	git-ls-files --stage >1-3.out &&
76bc82ca	89	diff -u M.out 1-3.out &&
c8596009 JH	90	check_cache_at bozbar dirty &&
	91	check_cache_at frotz dirty &&
	92	check_cache_at nitfol dirty'
	93
	94	echo '+100644 X 0 yomin' >expected
	95
	96	test_expect_success \
	97	'4 - carry forward local addition.' \
	98	'rm -f .git/index &&
1abb3f14 JH	99	git-read-tree $treeH &&
1abb3f14 JH	100	git-checkout-cache -u -f -q -a &&
c8596009	101	git-update-cache --add yomin &&
76bc82ca	102	read_tree_twoway $treeH $treeM &&
4d9d62fa	103	git-ls-files --stage >4.out \|\| return 1
76bc82ca	104	diff -u M.out 4.out >4diff.out
c8596009 JH	105	compare_change 4diff.out expected &&
	106	check_cache_at yomin clean'
	107
	108	test_expect_success \
	109	'5 - carry forward local addition.' \
	110	'rm -f .git/index &&
1abb3f14 JH	111	git-read-tree $treeH &&
1abb3f14 JH	112	git-checkout-cache -u -f -q -a &&
c8596009 JH	113	echo yomin >yomin &&
	114	git-update-cache --add yomin &&
	115	echo yomin yomin >yomin &&
76bc82ca	116	read_tree_twoway $treeH $treeM &&
4d9d62fa	117	git-ls-files --stage >5.out \|\| return 1
76bc82ca	118	diff -u M.out 5.out >5diff.out
c8596009 JH	119	compare_change 5diff.out expected &&
	120	check_cache_at yomin dirty'
	121
	122	test_expect_success \
	123	'6 - local addition already has the same.' \
	124	'rm -f .git/index &&
1abb3f14 JH	125	git-read-tree $treeH &&
1abb3f14 JH	126	git-checkout-cache -u -f -q -a &&
c8596009	127	git-update-cache --add frotz &&
76bc82ca	128	read_tree_twoway $treeH $treeM &&
c8596009	129	git-ls-files --stage >6.out &&
76bc82ca	130	diff -u M.out 6.out &&
c8596009 JH	131	check_cache_at frotz clean'
	132
	133	test_expect_success \
	134	'7 - local addition already has the same.' \
	135	'rm -f .git/index &&
1abb3f14 JH	136	git-read-tree $treeH &&
1abb3f14 JH	137	git-checkout-cache -u -f -q -a &&
c8596009 JH	138	echo frotz >frotz &&
	139	git-update-cache --add frotz &&
	140	echo frotz frotz >frotz &&
76bc82ca	141	read_tree_twoway $treeH $treeM &&
c8596009	142	git-ls-files --stage >7.out &&
76bc82ca	143	diff -u M.out 7.out &&
c8596009 JH	144	check_cache_at frotz dirty'
	145
	146	test_expect_success \
	147	'8 - conflicting addition.' \
	148	'rm -f .git/index &&
1abb3f14 JH	149	git-read-tree $treeH &&
1abb3f14 JH	150	git-checkout-cache -u -f -q -a &&
c8596009 JH	151	echo frotz frotz >frotz &&
c8596009 JH	152	git-update-cache --add frotz &&
76bc82ca	153	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	154
	155	test_expect_success \
	156	'9 - conflicting addition.' \
	157	'rm -f .git/index &&
1abb3f14 JH	158	git-read-tree $treeH &&
1abb3f14 JH	159	git-checkout-cache -u -f -q -a &&
c8596009 JH	160	echo frotz frotz >frotz &&
	161	git-update-cache --add frotz &&
	162	echo frotz >frotz &&
76bc82ca	163	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	164
	165	test_expect_success \
	166	'10 - path removed.' \
	167	'rm -f .git/index &&
1abb3f14 JH	168	git-read-tree $treeH &&
1abb3f14 JH	169	git-checkout-cache -u -f -q -a &&
c8596009 JH	170	echo rezrov >rezrov &&
c8596009 JH	171	git-update-cache --add rezrov &&
76bc82ca	172	read_tree_twoway $treeH $treeM &&
c8596009	173	git-ls-files --stage >10.out &&
76bc82ca	174	diff -u M.out 10.out'
c8596009 JH	175
	176	test_expect_success \
	177	'11 - dirty path removed.' \
	178	'rm -f .git/index &&
1abb3f14 JH	179	git-read-tree $treeH &&
1abb3f14 JH	180	git-checkout-cache -u -f -q -a &&
c8596009 JH	181	echo rezrov >rezrov &&
	182	git-update-cache --add rezrov &&
	183	echo rezrov rezrov >rezrov &&
76bc82ca	184	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	185
	186	test_expect_success \
	187	'12 - unmatching local changes being removed.' \
	188	'rm -f .git/index &&
1abb3f14 JH	189	git-read-tree $treeH &&
1abb3f14 JH	190	git-checkout-cache -u -f -q -a &&
c8596009 JH	191	echo rezrov rezrov >rezrov &&
c8596009 JH	192	git-update-cache --add rezrov &&
76bc82ca	193	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	194
	195	test_expect_success \
	196	'13 - unmatching local changes being removed.' \
	197	'rm -f .git/index &&
1abb3f14 JH	198	git-read-tree $treeH &&
1abb3f14 JH	199	git-checkout-cache -u -f -q -a &&
c8596009 JH	200	echo rezrov rezrov >rezrov &&
	201	git-update-cache --add rezrov &&
	202	echo rezrov >rezrov &&
76bc82ca	203	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	204
	205	cat >expected <<EOF
	206	-100644 X 0 nitfol
	207	+100644 X 0 nitfol
	208	EOF
	209
	210	test_expect_success \
	211	'14 - unchanged in two heads.' \
	212	'rm -f .git/index &&
1abb3f14 JH	213	git-read-tree $treeH &&
1abb3f14 JH	214	git-checkout-cache -u -f -q -a &&
c8596009 JH	215	echo nitfol nitfol >nitfol &&
c8596009 JH	216	git-update-cache --add nitfol &&
76bc82ca	217	read_tree_twoway $treeH $treeM &&
4d9d62fa	218	git-ls-files --stage >14.out \|\| return 1
76bc82ca	219	diff -u M.out 14.out >14diff.out
c8596009 JH	220	compare_change 14diff.out expected &&
	221	check_cache_at nitfol clean'
	222
	223	test_expect_success \
	224	'15 - unchanged in two heads.' \
	225	'rm -f .git/index &&
1abb3f14 JH	226	git-read-tree $treeH &&
1abb3f14 JH	227	git-checkout-cache -u -f -q -a &&
c8596009 JH	228	echo nitfol nitfol >nitfol &&
	229	git-update-cache --add nitfol &&
	230	echo nitfol nitfol nitfol >nitfol &&
76bc82ca	231	read_tree_twoway $treeH $treeM &&
4d9d62fa	232	git-ls-files --stage >15.out \|\| return 1
76bc82ca	233	diff -u M.out 15.out >15diff.out
c8596009 JH	234	compare_change 15diff.out expected &&
	235	check_cache_at nitfol dirty'
	236
	237	test_expect_success \
	238	'16 - conflicting local change.' \
	239	'rm -f .git/index &&
1abb3f14 JH	240	git-read-tree $treeH &&
1abb3f14 JH	241	git-checkout-cache -u -f -q -a &&
c8596009 JH	242	echo bozbar bozbar >bozbar &&
c8596009 JH	243	git-update-cache --add bozbar &&
76bc82ca	244	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	245
	246	test_expect_success \
	247	'17 - conflicting local change.' \
	248	'rm -f .git/index &&
1abb3f14 JH	249	git-read-tree $treeH &&
1abb3f14 JH	250	git-checkout-cache -u -f -q -a &&
c8596009 JH	251	echo bozbar bozbar >bozbar &&
	252	git-update-cache --add bozbar &&
	253	echo bozbar bozbar bozbar >bozbar &&
76bc82ca	254	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009 JH	255
	256	test_expect_success \
	257	'18 - local change already having a good result.' \
	258	'rm -f .git/index &&
1abb3f14 JH	259	git-read-tree $treeH &&
	260	git-checkout-cache -u -f -q -a &&
	261	cat bozbar-new >bozbar &&
c8596009	262	git-update-cache --add bozbar &&
76bc82ca	263	read_tree_twoway $treeH $treeM &&
c8596009	264	git-ls-files --stage >18.out &&
76bc82ca	265	diff -u M.out 18.out &&
c8596009 JH	266	check_cache_at bozbar clean'
	267
	268	test_expect_success \
	269	'19 - local change already having a good result, further modified.' \
	270	'rm -f .git/index &&
1abb3f14 JH	271	git-read-tree $treeH &&
	272	git-checkout-cache -u -f -q -a &&
	273	cat bozbar-new >bozbar &&
c8596009 JH	274	git-update-cache --add bozbar &&
c8596009 JH	275	echo gnusto gnusto >bozbar &&
76bc82ca	276	read_tree_twoway $treeH $treeM &&
c8596009	277	git-ls-files --stage >19.out &&
76bc82ca	278	diff -u M.out 19.out &&
c8596009 JH	279	check_cache_at bozbar dirty'
	280
	281	test_expect_success \
	282	'20 - no local change, use new tree.' \
	283	'rm -f .git/index &&
1abb3f14 JH	284	git-read-tree $treeH &&
	285	git-checkout-cache -u -f -q -a &&
	286	cat bozbar-old >bozbar &&
c8596009	287	git-update-cache --add bozbar &&
76bc82ca	288	read_tree_twoway $treeH $treeM &&
c8596009	289	git-ls-files --stage >20.out &&
76bc82ca	290	diff -u M.out 20.out &&
c8596009 JH	291	check_cache_at bozbar dirty'
	292
	293	test_expect_success \
	294	'21 - no local change, dirty cache.' \
	295	'rm -f .git/index &&
1abb3f14 JH	296	git-read-tree $treeH &&
	297	git-checkout-cache -u -f -q -a &&
	298	cat bozbar-old >bozbar &&
c8596009 JH	299	git-update-cache --add bozbar &&
c8596009 JH	300	echo gnusto gnusto >bozbar &&
76bc82ca	301	if read_tree_twoway $treeH $treeM; then false; else :; fi'
c8596009	302
1abb3f14 JH	303	# This fails with straight two-way fast forward.
	304	test_expect_success \
	305	'22 - local change cache updated.' \
	306	'rm -f .git/index &&
	307	git-read-tree $treeH &&
	308	git-checkout-cache -u -f -q -a &&
	309	sed -e "s/such as/SUCH AS/" bozbar-old >bozbar &&
	310	git-update-cache --add bozbar &&
	311	if read_tree_twoway $treeH $treeM; then false; else :; fi'
	312
c8596009 JH	313	# Also make sure we did not break DF vs DF/DF case.
	314	test_expect_success \
	315	'DF vs DF/DF case setup.' \
	316	'rm -f .git/index &&
	317	echo DF >DF &&
	318	git-update-cache --add DF &&
	319	treeDF=`git-write-tree` &&
	320	echo treeDF $treeDF &&
	321	git-ls-tree $treeDF &&
	322
	323	rm -f DF &&
	324	mkdir DF &&
	325	echo DF/DF >DF/DF &&
	326	git-update-cache --add --remove DF DF/DF &&
	327	treeDFDF=`git-write-tree` &&
	328	echo treeDFDF $treeDFDF &&
	329	git-ls-tree $treeDFDF &&
	330	git-ls-files --stage >DFDF.out'
	331
	332	test_expect_success \
	333	'DF vs DF/DF case test.' \
	334	'rm -f .git/index &&
	335	rm -fr DF &&
	336	echo DF >DF &&
	337	git-update-cache --add DF &&
76bc82ca	338	read_tree_twoway $treeDF $treeDFDF &&
c8596009	339	git-ls-files --stage >DFDFcheck.out &&
76bc82ca JH	340	diff -u DFDF.out DFDFcheck.out &&
	341	check_cache_at DF/DF dirty &&
	342	:'
c8596009 JH	343
c8596009 JH	344	test_done