t/t7405-submodule-merge.sh - jrn/git - Git at Google

 #!/bin/sh

 test_description='merging with submodules'

 . ./test-lib.sh

 #
 # history
 #
 #        a --- c
 #      /   \ /
 # root      X
 #      \   / \
 #        b --- d
 #

 test_expect_success setup '

 	mkdir sub &&
 	(cd sub &&
 	 git init &&
 	 echo original > file &&
 	 git add file &&
 	 test_tick &&
 	 git commit -m sub-root) &&
 	git add sub &&
 	test_tick &&
 	git commit -m root &&

 	git checkout -b a master &&
 	(cd sub &&
 	 echo A > file &&
 	 git add file &&
 	 test_tick &&
 	 git commit -m sub-a) &&
 	git add sub &&
 	test_tick &&
 	git commit -m a &&

 	git checkout -b b master &&
 	(cd sub &&
 	 echo B > file &&
 	 git add file &&
 	 test_tick &&
 	 git commit -m sub-b) &&
 	git add sub &&
 	test_tick &&
 	git commit -m b &&

 	git checkout -b c a &&
 	git merge -s ours b &&

 	git checkout -b d b &&
 	git merge -s ours a
 '

 # History setup
 #
 #             b
 #           /   \
 #  init -- a     d
 #    \      \   /
 #     g       c
 #
 # a in the main repository records to sub-a in the submodule and
 # analogous b and c. d should be automatically found by merging c into
 # b in the main repository.
 test_expect_success 'setup for merge search' '
 	mkdir merge-search &&
 	(cd merge-search &&
 	git init &&
 	mkdir sub &&
 	(cd sub &&
 	 git init &&
 	 echo "file-a" > file-a &&
 	 git add file-a &&
 	 git commit -m "sub-a" &&
 	 git branch sub-a) &&
 	git commit --allow-empty -m init &&
 	git branch init &&
 	git add sub &&
 	git commit -m "a" &&
 	git branch a &&

 	git checkout -b b &&
 	(cd sub &&
 	 git checkout -b sub-b &&
 	 echo "file-b" > file-b &&
 	 git add file-b &&
 	 git commit -m "sub-b") &&
 	git commit -a -m "b" &&

 	git checkout -b c a &&
 	(cd sub &&
 	 git checkout -b sub-c sub-a &&
 	 echo "file-c" > file-c &&
 	 git add file-c &&
 	 git commit -m "sub-c") &&
 	git commit -a -m "c" &&

 	git checkout -b d a &&
 	(cd sub &&
 	 git checkout -b sub-d sub-b &&
 	 git merge sub-c) &&
 	git commit -a -m "d" &&
 	git branch test b &&

 	git checkout -b g init &&
 	(cd sub &&
 	 git checkout -b sub-g sub-c) &&
 	git add sub &&
 	git commit -a -m "g")
 '

 test_expect_success 'merge with one side as a fast-forward of the other' '
 	(cd merge-search &&
 	 git checkout -b test-forward b &&
 	 git merge d &&
 	 git ls-tree test-forward sub | cut -f1 | cut -f3 -d" " > actual &&
 	 (cd sub &&
 	  git rev-parse sub-d > ../expect) &&
 	 test_cmp expect actual)
 '

 test_expect_success 'merging should conflict for non fast-forward' '
 	(cd merge-search &&
 	 git checkout -b test-nonforward b &&
 	 (cd sub &&
 	  git rev-parse sub-d > ../expect) &&
 	 test_must_fail git merge c 2> actual  &&
 	 grep $(cat expect) actual > /dev/null &&
 	 git reset --hard)
 '

 test_expect_success 'merging should fail for ambiguous common parent' '
 	(cd merge-search &&
 	git checkout -b test-ambiguous b &&
 	(cd sub &&
 	 git checkout -b ambiguous sub-b &&
 	 git merge sub-c &&
 	 git rev-parse sub-d > ../expect1 &&
 	 git rev-parse ambiguous > ../expect2) &&
 	test_must_fail git merge c 2> actual &&
 	grep $(cat expect1) actual > /dev/null &&
 	grep $(cat expect2) actual > /dev/null &&
 	git reset --hard)
 '

 # in a situation like this
 #
 # submodule tree:
 #
 #    sub-a --- sub-b --- sub-d
 #
 # main tree:
 #
 #    e (sub-a)
 #   /
 #  bb (sub-b)
 #   \
 #    f (sub-d)
 #
 # A merge between e and f should fail because one of the submodule
 # commits (sub-a) does not descend from the submodule merge-base (sub-b).
 #
 test_expect_success 'merging should fail for changes that are backwards' '
 	(cd merge-search &&
 	git checkout -b bb a &&
 	(cd sub &&
 	 git checkout sub-b) &&
 	git commit -a -m "bb" &&

 	git checkout -b e bb &&
 	(cd sub &&
 	 git checkout sub-a) &&
 	git commit -a -m "e" &&

 	git checkout -b f bb &&
 	(cd sub &&
 	 git checkout sub-d) &&
 	git commit -a -m "f" &&

 	git checkout -b test-backward e &&
 	test_must_fail git merge f)
 '


 # Check that the conflicting submodule is detected when it is
 # in the common ancestor. status should be 'U00...00"
 test_expect_success 'git submodule status should display the merge conflict properly with merge base' '
        (cd merge-search &&
        cat >.gitmodules <<EOF &&
 [submodule "sub"]
        path = sub
        url = $TRASH_DIRECTORY/sub
 EOF
        cat >expect <<EOF &&
 U0000000000000000000000000000000000000000 sub
 EOF
        git submodule status > actual &&
        test_cmp expect actual &&
 	git reset --hard)
 '

 # Check that the conflicting submodule is detected when it is
 # not in the common ancestor. status should be 'U00...00"
 test_expect_success 'git submodule status should display the merge conflict properly without merge-base' '
        (cd merge-search &&
 	git checkout -b test-no-merge-base g &&
 	test_must_fail git merge b &&
        cat >.gitmodules <<EOF &&
 [submodule "sub"]
        path = sub
        url = $TRASH_DIRECTORY/sub
 EOF
        cat >expect <<EOF &&
 U0000000000000000000000000000000000000000 sub
 EOF
        git submodule status > actual &&
        test_cmp expect actual &&
        git reset --hard)
 '


 test_expect_success 'merging with a modify/modify conflict between merge bases' '
 	git reset --hard HEAD &&
 	git checkout -b test2 c &&
 	git merge d
 '

 # canonical criss-cross history in top and submodule
 test_expect_success 'setup for recursive merge with submodule' '
 	mkdir merge-recursive &&
 	(cd merge-recursive &&
 	 git init &&
 	 mkdir sub &&
 	 (cd sub &&
 	  git init &&
 	  test_commit a &&
 	  git checkout -b sub-b master &&
 	  test_commit b &&
 	  git checkout -b sub-c master &&
 	  test_commit c &&
 	  git checkout -b sub-bc sub-b &&
 	  git merge sub-c &&
 	  git checkout -b sub-cb sub-c &&
 	  git merge sub-b &&
 	  git checkout master) &&
 	 git add sub &&
 	 git commit -m a &&
 	 git checkout -b top-b master &&
 	 (cd sub && git checkout sub-b) &&
 	 git add sub &&
 	 git commit -m b &&
 	 git checkout -b top-c master &&
 	 (cd sub && git checkout sub-c) &&
 	 git add sub &&
 	 git commit -m c &&
 	 git checkout -b top-bc top-b &&
 	 git merge -s ours --no-commit top-c &&
 	 (cd sub && git checkout sub-bc) &&
 	 git add sub &&
 	 git commit -m bc &&
 	 git checkout -b top-cb top-c &&
 	 git merge -s ours --no-commit top-b &&
 	 (cd sub && git checkout sub-cb) &&
 	 git add sub &&
 	 git commit -m cb)
 '

 # merge should leave submodule unmerged in index
 test_expect_success 'recursive merge with submodule' '
 	(cd merge-recursive &&
 	 test_must_fail git merge top-bc &&
 	 echo "160000 $(git rev-parse top-cb:sub) 2	sub" > expect2 &&
 	 echo "160000 $(git rev-parse top-bc:sub) 3	sub" > expect3 &&
 	 git ls-files -u > actual &&
 	 grep "$(cat expect2)" actual > /dev/null &&
 	 grep "$(cat expect3)" actual > /dev/null)
 '

 # File/submodule conflict
 #   Commit O: <empty>
 #   Commit A: path (submodule)
 #   Commit B: path
 #   Expected: path/ is submodule and file contents for B's path are somewhere

 test_expect_success 'setup file/submodule conflict' '
 	test_create_repo file-submodule &&
 	(
 		cd file-submodule &&

 		git commit --allow-empty -m O &&

 		git branch A &&
 		git branch B &&

 		git checkout B &&
 		echo content >path &&
 		git add path &&
 		git commit -m B &&

 		git checkout A &&
 		test_create_repo path &&
 		test_commit -C path world &&
 		git submodule add ./path &&
 		git commit -m A
 	)
 '

 test_expect_failure 'file/submodule conflict' '
 	test_when_finished "git -C file-submodule reset --hard" &&
 	(
 		cd file-submodule &&

 		git checkout A^0 &&
 		test_must_fail git merge B^0 &&

 		git ls-files -s >out &&
 		test_line_count = 3 out &&
 		git ls-files -u >out &&
 		test_line_count = 2 out &&

 		# path/ is still a submodule
 		test_path_is_dir path/.git &&

 		# There is a submodule at "path", so B:path cannot be written
 		# there.  We expect it to be written somewhere in the same
 		# directory, though, so just grep for its content in all
 		# files, and ignore "grep: path: Is a directory" message
 		echo Checking if contents from B:path showed up anywhere &&
 		grep -q content * 2>/dev/null
 	)
 '

 test_expect_success 'file/submodule conflict; merge --abort works afterward' '
 	test_when_finished "git -C file-submodule reset --hard" &&
 	(
 		cd file-submodule &&

 		git checkout A^0 &&
 		test_must_fail git merge B^0 >out 2>err &&

 		test_path_is_file .git/MERGE_HEAD &&
 		git merge --abort
 	)
 '

 # Directory/submodule conflict
 #   Commit O: <empty>
 #   Commit A: path (submodule), with sole tracked file named 'world'
 #   Commit B1: path/file
 #   Commit B2: path/world
 #
 #   Expected from merge of A & B1:
 #     Contents under path/ from commit B1 are renamed elsewhere; we do not
 #     want to write files from one of our tracked directories into a submodule
 #
 #   Expected from merge of A & B2:
 #     Similar to last merge, but with a slight twist: we don't want paths
 #     under the submodule to be treated as untracked or in the way.

 test_expect_success 'setup directory/submodule conflict' '
 	test_create_repo directory-submodule &&
 	(
 		cd directory-submodule &&

 		git commit --allow-empty -m O &&

 		git branch A &&
 		git branch B1 &&
 		git branch B2 &&

 		git checkout B1 &&
 		mkdir path &&
 		echo contents >path/file &&
 		git add path/file &&
 		git commit -m B1 &&

 		git checkout B2 &&
 		mkdir path &&
 		echo contents >path/world &&
 		git add path/world &&
 		git commit -m B2 &&

 		git checkout A &&
 		test_create_repo path &&
 		test_commit -C path hello world &&
 		git submodule add ./path &&
 		git commit -m A
 	)
 '

 test_expect_failure 'directory/submodule conflict; keep submodule clean' '
 	test_when_finished "git -C directory-submodule reset --hard" &&
 	(
 		cd directory-submodule &&

 		git checkout A^0 &&
 		test_must_fail git merge B1^0 &&

 		git ls-files -s >out &&
 		test_line_count = 3 out &&
 		git ls-files -u >out &&
 		test_line_count = 1 out &&

 		# path/ is still a submodule
 		test_path_is_dir path/.git &&

 		echo Checking if contents from B1:path/file showed up &&
 		# Would rather use grep -r, but that is GNU extension...
 		git ls-files -co | xargs grep -q contents 2>/dev/null &&

 		# However, B1:path/file should NOT have shown up at path/file,
 		# because we should not write into the submodule
 		test_path_is_missing path/file
 	)
 '

 test_expect_failure 'directory/submodule conflict; should not treat submodule files as untracked or in the way' '
 	test_when_finished "git -C directory-submodule/path reset --hard" &&
 	test_when_finished "git -C directory-submodule reset --hard" &&
 	(
 		cd directory-submodule &&

 		git checkout A^0 &&
 		test_must_fail git merge B2^0 >out 2>err &&

 		# We do not want files within the submodule to prevent the
 		# merge from starting; we should not be writing to such paths
 		# anyway.
 		test_i18ngrep ! "refusing to lose untracked file at" err
 	)
 '

 test_expect_failure 'directory/submodule conflict; merge --abort works afterward' '
 	test_when_finished "git -C directory-submodule/path reset --hard" &&
 	test_when_finished "git -C directory-submodule reset --hard" &&
 	(
 		cd directory-submodule &&

 		git checkout A^0 &&
 		test_must_fail git merge B2^0 &&
 		test_path_is_file .git/MERGE_HEAD &&

 		# merge --abort should succeed, should clear .git/MERGE_HEAD,
 		# and should not leave behind any conflicted files
 		git merge --abort &&
 		test_path_is_missing .git/MERGE_HEAD &&
 		git ls-files -u >conflicts &&
 		test_must_be_empty conflicts
 	)
 '

 test_done
	#!/bin/sh

	test_description='merging with submodules'

	. ./test-lib.sh

	#
	# history
	#
	# a --- c
	# / \ /
	# root X
	# \ / \
	# b --- d
	#

	test_expect_success setup '

	mkdir sub &&
	(cd sub &&
	git init &&
	echo original > file &&
	git add file &&
	test_tick &&
	git commit -m sub-root) &&
	git add sub &&
	test_tick &&
	git commit -m root &&

	git checkout -b a master &&
	(cd sub &&
	echo A > file &&
	git add file &&
	test_tick &&
	git commit -m sub-a) &&
	git add sub &&
	test_tick &&
	git commit -m a &&

	git checkout -b b master &&
	(cd sub &&
	echo B > file &&
	git add file &&
	test_tick &&
	git commit -m sub-b) &&
	git add sub &&
	test_tick &&
	git commit -m b &&

	git checkout -b c a &&
	git merge -s ours b &&

	git checkout -b d b &&
	git merge -s ours a
	'

	# History setup
	#
	# b
	# / \
	# init -- a d
	# \ \ /
	# g c
	#
	# a in the main repository records to sub-a in the submodule and
	# analogous b and c. d should be automatically found by merging c into
	# b in the main repository.
	test_expect_success 'setup for merge search' '
	mkdir merge-search &&
	(cd merge-search &&
	git init &&
	mkdir sub &&
	(cd sub &&
	git init &&
	echo "file-a" > file-a &&
	git add file-a &&
	git commit -m "sub-a" &&
	git branch sub-a) &&
	git commit --allow-empty -m init &&
	git branch init &&
	git add sub &&
	git commit -m "a" &&
	git branch a &&

	git checkout -b b &&
	(cd sub &&
	git checkout -b sub-b &&
	echo "file-b" > file-b &&
	git add file-b &&
	git commit -m "sub-b") &&
	git commit -a -m "b" &&

	git checkout -b c a &&
	(cd sub &&
	git checkout -b sub-c sub-a &&
	echo "file-c" > file-c &&
	git add file-c &&
	git commit -m "sub-c") &&
	git commit -a -m "c" &&

	git checkout -b d a &&
	(cd sub &&
	git checkout -b sub-d sub-b &&
	git merge sub-c) &&
	git commit -a -m "d" &&
	git branch test b &&

	git checkout -b g init &&
	(cd sub &&
	git checkout -b sub-g sub-c) &&
	git add sub &&
	git commit -a -m "g")
	'

	test_expect_success 'merge with one side as a fast-forward of the other' '
	(cd merge-search &&
	git checkout -b test-forward b &&
	git merge d &&
	git ls-tree test-forward sub \| cut -f1 \| cut -f3 -d" " > actual &&
	(cd sub &&
	git rev-parse sub-d > ../expect) &&
	test_cmp expect actual)
	'

	test_expect_success 'merging should conflict for non fast-forward' '
	(cd merge-search &&
	git checkout -b test-nonforward b &&
	(cd sub &&
	git rev-parse sub-d > ../expect) &&
	test_must_fail git merge c 2> actual &&
	grep $(cat expect) actual > /dev/null &&
	git reset --hard)
	'

	test_expect_success 'merging should fail for ambiguous common parent' '
	(cd merge-search &&
	git checkout -b test-ambiguous b &&
	(cd sub &&
	git checkout -b ambiguous sub-b &&
	git merge sub-c &&
	git rev-parse sub-d > ../expect1 &&
	git rev-parse ambiguous > ../expect2) &&
	test_must_fail git merge c 2> actual &&
	grep $(cat expect1) actual > /dev/null &&
	grep $(cat expect2) actual > /dev/null &&
	git reset --hard)
	'

	# in a situation like this
	#
	# submodule tree:
	#
	# sub-a --- sub-b --- sub-d
	#
	# main tree:
	#
	# e (sub-a)
	# /
	# bb (sub-b)
	# \
	# f (sub-d)
	#
	# A merge between e and f should fail because one of the submodule
	# commits (sub-a) does not descend from the submodule merge-base (sub-b).
	#
	test_expect_success 'merging should fail for changes that are backwards' '
	(cd merge-search &&
	git checkout -b bb a &&
	(cd sub &&
	git checkout sub-b) &&
	git commit -a -m "bb" &&

	git checkout -b e bb &&
	(cd sub &&
	git checkout sub-a) &&
	git commit -a -m "e" &&

	git checkout -b f bb &&
	(cd sub &&
	git checkout sub-d) &&
	git commit -a -m "f" &&

	git checkout -b test-backward e &&
	test_must_fail git merge f)
	'


	# Check that the conflicting submodule is detected when it is
	# in the common ancestor. status should be 'U00...00"
	test_expect_success 'git submodule status should display the merge conflict properly with merge base' '
	(cd merge-search &&
	cat >.gitmodules <<EOF &&
	[submodule "sub"]
	path = sub
	url = $TRASH_DIRECTORY/sub
	EOF
	cat >expect <<EOF &&
	U0000000000000000000000000000000000000000 sub
	EOF
	git submodule status > actual &&
	test_cmp expect actual &&
	git reset --hard)
	'

	# Check that the conflicting submodule is detected when it is
	# not in the common ancestor. status should be 'U00...00"
	test_expect_success 'git submodule status should display the merge conflict properly without merge-base' '
	(cd merge-search &&
	git checkout -b test-no-merge-base g &&
	test_must_fail git merge b &&
	cat >.gitmodules <<EOF &&
	[submodule "sub"]
	path = sub
	url = $TRASH_DIRECTORY/sub
	EOF
	cat >expect <<EOF &&
	U0000000000000000000000000000000000000000 sub
	EOF
	git submodule status > actual &&
	test_cmp expect actual &&
	git reset --hard)
	'


	test_expect_success 'merging with a modify/modify conflict between merge bases' '
	git reset --hard HEAD &&
	git checkout -b test2 c &&
	git merge d
	'

	# canonical criss-cross history in top and submodule
	test_expect_success 'setup for recursive merge with submodule' '
	mkdir merge-recursive &&
	(cd merge-recursive &&
	git init &&
	mkdir sub &&
	(cd sub &&
	git init &&
	test_commit a &&
	git checkout -b sub-b master &&
	test_commit b &&
	git checkout -b sub-c master &&
	test_commit c &&
	git checkout -b sub-bc sub-b &&
	git merge sub-c &&
	git checkout -b sub-cb sub-c &&
	git merge sub-b &&
	git checkout master) &&
	git add sub &&
	git commit -m a &&
	git checkout -b top-b master &&
	(cd sub && git checkout sub-b) &&
	git add sub &&
	git commit -m b &&
	git checkout -b top-c master &&
	(cd sub && git checkout sub-c) &&
	git add sub &&
	git commit -m c &&
	git checkout -b top-bc top-b &&
	git merge -s ours --no-commit top-c &&
	(cd sub && git checkout sub-bc) &&
	git add sub &&
	git commit -m bc &&
	git checkout -b top-cb top-c &&
	git merge -s ours --no-commit top-b &&
	(cd sub && git checkout sub-cb) &&
	git add sub &&
	git commit -m cb)
	'

	# merge should leave submodule unmerged in index
	test_expect_success 'recursive merge with submodule' '
	(cd merge-recursive &&
	test_must_fail git merge top-bc &&
	echo "160000 $(git rev-parse top-cb:sub) 2 sub" > expect2 &&
	echo "160000 $(git rev-parse top-bc:sub) 3 sub" > expect3 &&
	git ls-files -u > actual &&
	grep "$(cat expect2)" actual > /dev/null &&
	grep "$(cat expect3)" actual > /dev/null)
	'

	# File/submodule conflict
	# Commit O: <empty>
	# Commit A: path (submodule)
	# Commit B: path
	# Expected: path/ is submodule and file contents for B's path are somewhere

	test_expect_success 'setup file/submodule conflict' '
	test_create_repo file-submodule &&
	(
	cd file-submodule &&

	git commit --allow-empty -m O &&

	git branch A &&
	git branch B &&

	git checkout B &&
	echo content >path &&
	git add path &&
	git commit -m B &&

	git checkout A &&
	test_create_repo path &&
	test_commit -C path world &&
	git submodule add ./path &&
	git commit -m A
	)
	'

	test_expect_failure 'file/submodule conflict' '
	test_when_finished "git -C file-submodule reset --hard" &&
	(
	cd file-submodule &&

	git checkout A^0 &&
	test_must_fail git merge B^0 &&

	git ls-files -s >out &&
	test_line_count = 3 out &&
	git ls-files -u >out &&
	test_line_count = 2 out &&

	# path/ is still a submodule
	test_path_is_dir path/.git &&

	# There is a submodule at "path", so B:path cannot be written
	# there. We expect it to be written somewhere in the same
	# directory, though, so just grep for its content in all
	# files, and ignore "grep: path: Is a directory" message
	echo Checking if contents from B:path showed up anywhere &&
	grep -q content * 2>/dev/null
	)
	'

	test_expect_success 'file/submodule conflict; merge --abort works afterward' '
	test_when_finished "git -C file-submodule reset --hard" &&
	(
	cd file-submodule &&

	git checkout A^0 &&
	test_must_fail git merge B^0 >out 2>err &&

	test_path_is_file .git/MERGE_HEAD &&
	git merge --abort
	)
	'

	# Directory/submodule conflict
	# Commit O: <empty>
	# Commit A: path (submodule), with sole tracked file named 'world'
	# Commit B1: path/file
	# Commit B2: path/world
	#
	# Expected from merge of A & B1:
	# Contents under path/ from commit B1 are renamed elsewhere; we do not
	# want to write files from one of our tracked directories into a submodule
	#
	# Expected from merge of A & B2:
	# Similar to last merge, but with a slight twist: we don't want paths
	# under the submodule to be treated as untracked or in the way.

	test_expect_success 'setup directory/submodule conflict' '
	test_create_repo directory-submodule &&
	(
	cd directory-submodule &&

	git commit --allow-empty -m O &&

	git branch A &&
	git branch B1 &&
	git branch B2 &&

	git checkout B1 &&
	mkdir path &&
	echo contents >path/file &&
	git add path/file &&
	git commit -m B1 &&

	git checkout B2 &&
	mkdir path &&
	echo contents >path/world &&
	git add path/world &&
	git commit -m B2 &&

	git checkout A &&
	test_create_repo path &&
	test_commit -C path hello world &&
	git submodule add ./path &&
	git commit -m A
	)
	'

	test_expect_failure 'directory/submodule conflict; keep submodule clean' '
	test_when_finished "git -C directory-submodule reset --hard" &&
	(
	cd directory-submodule &&

	git checkout A^0 &&
	test_must_fail git merge B1^0 &&

	git ls-files -s >out &&
	test_line_count = 3 out &&
	git ls-files -u >out &&
	test_line_count = 1 out &&

	# path/ is still a submodule
	test_path_is_dir path/.git &&

	echo Checking if contents from B1:path/file showed up &&
	# Would rather use grep -r, but that is GNU extension...
	git ls-files -co \| xargs grep -q contents 2>/dev/null &&

	# However, B1:path/file should NOT have shown up at path/file,
	# because we should not write into the submodule
	test_path_is_missing path/file
	)
	'

	test_expect_failure 'directory/submodule conflict; should not treat submodule files as untracked or in the way' '
	test_when_finished "git -C directory-submodule/path reset --hard" &&
	test_when_finished "git -C directory-submodule reset --hard" &&
	(
	cd directory-submodule &&

	git checkout A^0 &&
	test_must_fail git merge B2^0 >out 2>err &&

	# We do not want files within the submodule to prevent the
	# merge from starting; we should not be writing to such paths
	# anyway.
	test_i18ngrep ! "refusing to lose untracked file at" err
	)
	'

	test_expect_failure 'directory/submodule conflict; merge --abort works afterward' '
	test_when_finished "git -C directory-submodule/path reset --hard" &&
	test_when_finished "git -C directory-submodule reset --hard" &&
	(
	cd directory-submodule &&

	git checkout A^0 &&
	test_must_fail git merge B2^0 &&
	test_path_is_file .git/MERGE_HEAD &&

	# merge --abort should succeed, should clear .git/MERGE_HEAD,
	# and should not leave behind any conflicted files
	git merge --abort &&
	test_path_is_missing .git/MERGE_HEAD &&
	git ls-files -u >conflicts &&
	test_must_be_empty conflicts
	)
	'

	test_done