[thirdparty/git.git] / t / t3600-rm.sh

#!/bin/sh
#
# Copyright (c) 2006 Carl D. Worth
#

test_description='Test of the various options to git rm.'

. ./test-lib.sh

# Setup some files to be removed, some with funny characters
test_expect_success \
    'Initialize test directory' \
    "touch -- foo bar baz 'space embedded' -q &&
     git add -- foo bar baz 'space embedded' -q &&
     git commit -m 'add normal files'"

if touch -- 'tab	embedded' 'newline
embedded' 2>/dev/null
then
	test_set_prereq FUNNYNAMES
else
	say 'Your filesystem does not allow tabs in filenames.'
fi

test_expect_success FUNNYNAMES 'add files with funny names' "
     git add -- 'tab	embedded' 'newline
embedded' &&
     git commit -m 'add files with tabs and newlines'
"

test_expect_success \
    'Pre-check that foo exists and is in index before git rm foo' \
    '[ -f foo ] && git ls-files --error-unmatch foo'

test_expect_success \
    'Test that git rm foo succeeds' \
    'git rm --cached foo'

test_expect_success \
    'Test that git rm --cached foo succeeds if the index matches the file' \
    'echo content > foo
     git add foo
     git rm --cached foo'

test_expect_success \
    'Test that git rm --cached foo succeeds if the index matches the file' \
    'echo content > foo
     git add foo
     git commit -m foo
     echo "other content" > foo
     git rm --cached foo'

test_expect_success \
    'Test that git rm --cached foo fails if the index matches neither the file nor HEAD' '
     echo content > foo
     git add foo
     git commit -m foo
     echo "other content" > foo
     git add foo
     echo "yet another content" > foo
     test_must_fail git rm --cached foo
'

test_expect_success \
    'Test that git rm --cached -f foo works in case where --cached only did not' \
    'echo content > foo
     git add foo
     git commit -m foo
     echo "other content" > foo
     git add foo
     echo "yet another content" > foo
     git rm --cached -f foo'

test_expect_success \
    'Post-check that foo exists but is not in index after git rm foo' \
    '[ -f foo ] && test_must_fail git ls-files --error-unmatch foo'

test_expect_success \
    'Pre-check that bar exists and is in index before "git rm bar"' \
    '[ -f bar ] && git ls-files --error-unmatch bar'

test_expect_success \
    'Test that "git rm bar" succeeds' \
    'git rm bar'

test_expect_success \
    'Post-check that bar does not exist and is not in index after "git rm -f bar"' \
    '! [ -f bar ] && test_must_fail git ls-files --error-unmatch bar'

test_expect_success \
    'Test that "git rm -- -q" succeeds (remove a file that looks like an option)' \
    'git rm -- -q'

test_expect_success FUNNYNAMES \
    "Test that \"git rm -f\" succeeds with embedded space, tab, or newline characters." \
    "git rm -f 'space embedded' 'tab	embedded' 'newline
embedded'"

test_expect_success SANITY 'Test that "git rm -f" fails if its rm fails' '
	chmod a-w . &&
	test_must_fail git rm -f baz &&
	chmod 775 .
'

test_expect_success \
    'When the rm in "git rm -f" fails, it should not remove the file from the index' \
    'git ls-files --error-unmatch baz'

test_expect_success 'Remove nonexistent file with --ignore-unmatch' '
	git rm --ignore-unmatch nonexistent
'

test_expect_success '"rm" command printed' '
	echo frotz > test-file &&
	git add test-file &&
	git commit -m "add file for rm test" &&
	git rm test-file > rm-output &&
	test `grep "^rm " rm-output | wc -l` = 1 &&
	rm -f test-file rm-output &&
	git commit -m "remove file from rm test"
'

test_expect_success '"rm" command suppressed with --quiet' '
	echo frotz > test-file &&
	git add test-file &&
	git commit -m "add file for rm --quiet test" &&
	git rm --quiet test-file > rm-output &&
	test `wc -l < rm-output` = 0 &&
	rm -f test-file rm-output &&
	git commit -m "remove file from rm --quiet test"
'

# Now, failure cases.
test_expect_success 'Re-add foo and baz' '
	git add foo baz &&
	git ls-files --error-unmatch foo baz
'

test_expect_success 'Modify foo -- rm should refuse' '
	echo >>foo &&
	test_must_fail git rm foo baz &&
	test -f foo &&
	test -f baz &&
	git ls-files --error-unmatch foo baz
'

test_expect_success 'Modified foo -- rm -f should work' '
	git rm -f foo baz &&
	test ! -f foo &&
	test ! -f baz &&
	test_must_fail git ls-files --error-unmatch foo &&
	test_must_fail git ls-files --error-unmatch bar
'

test_expect_success 'Re-add foo and baz for HEAD tests' '
	echo frotz >foo &&
	git checkout HEAD -- baz &&
	git add foo baz &&
	git ls-files --error-unmatch foo baz
'

test_expect_success 'foo is different in index from HEAD -- rm should refuse' '
	test_must_fail git rm foo baz &&
	test -f foo &&
	test -f baz &&
	git ls-files --error-unmatch foo baz
'

test_expect_success 'but with -f it should work.' '
	git rm -f foo baz &&
	test ! -f foo &&
	test ! -f baz &&
	test_must_fail git ls-files --error-unmatch foo
	test_must_fail git ls-files --error-unmatch baz
'

test_expect_success 'refuse to remove cached empty file with modifications' '
	>empty &&
	git add empty &&
	echo content >empty &&
	test_must_fail git rm --cached empty
'

test_expect_success 'remove intent-to-add file without --force' '
	echo content >intent-to-add &&
	git add -N intent-to-add
	git rm --cached intent-to-add
'

test_expect_success 'Recursive test setup' '
	mkdir -p frotz &&
	echo qfwfq >frotz/nitfol &&
	git add frotz &&
	git commit -m "subdir test"
'

test_expect_success 'Recursive without -r fails' '
	test_must_fail git rm frotz &&
	test -d frotz &&
	test -f frotz/nitfol
'

test_expect_success 'Recursive with -r but dirty' '
	echo qfwfq >>frotz/nitfol
	test_must_fail git rm -r frotz &&
	test -d frotz &&
	test -f frotz/nitfol
'

test_expect_success 'Recursive with -r -f' '
	git rm -f -r frotz &&
	! test -f frotz/nitfol &&
	! test -d frotz
'

test_expect_success 'Remove nonexistent file returns nonzero exit status' '
	test_must_fail git rm nonexistent
'

test_expect_success 'Call "rm" from outside the work tree' '
	mkdir repo &&
	(cd repo &&
	 git init &&
	 echo something > somefile &&
	 git add somefile &&
	 git commit -m "add a file" &&
	 (cd .. &&
	  git --git-dir=repo/.git --work-tree=repo rm somefile) &&
	test_must_fail git ls-files --error-unmatch somefile)
'

test_expect_success 'refresh index before checking if it is up-to-date' '

	git reset --hard &&
	test-chmtime -86400 frotz/nitfol &&
	git rm frotz/nitfol &&
	test ! -f frotz/nitfol

'

test_expect_success 'choking "git rm" should not let it die with cruft' '
	git reset -q --hard &&
	i=0 &&
	while test $i -lt 12000
	do
	    echo "100644 $_z40 0	some-file-$i"
	    i=$(( $i + 1 ))
	done | git update-index --index-info &&
	git rm -n "some-file-*" | :;
	test -f .git/index.lock
	status=$?
	rm -f .git/index.lock
	git reset -q --hard
	test "$status" != 0
'

test_expect_success 'rm removes subdirectories recursively' '
	mkdir -p dir/subdir/subsubdir &&
	echo content >dir/subdir/subsubdir/file &&
	git add dir/subdir/subsubdir/file &&
	git rm -f dir/subdir/subsubdir/file &&
	! test -d dir
'

cat >expect <<EOF
D  submod
EOF

cat >expect.modified <<EOF
 M submod
EOF

test_expect_success 'rm removes empty submodules from work tree' '
	mkdir submod &&
	git update-index --add --cacheinfo 160000 $(git rev-parse HEAD) submod &&
	git config -f .gitmodules submodule.sub.url ./. &&
	git config -f .gitmodules submodule.sub.path submod &&
	git submodule init &&
	git add .gitmodules &&
	git commit -m "add submodule" &&
	git rm submod &&
	test ! -e submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm removes removed submodule from index' '
	git reset --hard &&
	git submodule update &&
	rm -rf submod &&
	git rm submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm removes work tree of unmodified submodules' '
	git reset --hard &&
	git submodule update &&
	git rm submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm removes a submodule with a trailing /' '
	git reset --hard &&
	git submodule update &&
	git rm submod/ &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm fails when given a file with a trailing /' '
	test_must_fail git rm empty/
'

test_expect_success 'rm succeeds when given a directory with a trailing /' '
	git rm -r frotz/
'

test_expect_success 'rm of a populated submodule with different HEAD fails unless forced' '
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		git checkout HEAD^
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated submodule with modifications fails unless forced' '
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		echo X >empty
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated submodule with untracked files fails unless forced' '
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		echo X >untracked
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'setup submodule conflict' '
	git reset --hard &&
	git submodule update &&
	git checkout -b branch1 &&
	echo 1 >nitfol &&
	git add nitfol &&
	git commit -m "added nitfol 1" &&
	git checkout -b branch2 master &&
	echo 2 >nitfol &&
	git add nitfol &&
	git commit -m "added nitfol 2" &&
	git checkout -b conflict1 master &&
	(cd submod &&
		git fetch &&
		git checkout branch1
	) &&
	git add submod &&
	git commit -m "submod 1" &&
	git checkout -b conflict2 master &&
	(cd submod &&
		git checkout branch2
	) &&
	git add submod &&
	git commit -m "submod 2"
'

cat >expect.conflict <<EOF
UU submod
EOF

test_expect_success 'rm removes work tree of unmodified conflicted submodule' '
	git checkout conflict1 &&
	git reset --hard &&
	git submodule update &&
	test_must_fail git merge conflict2 &&
	git rm submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a conflicted populated submodule with different HEAD fails unless forced' '
	git checkout conflict1 &&
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		git checkout HEAD^
	) &&
	test_must_fail git merge conflict2 &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.conflict actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a conflicted populated submodule with modifications fails unless forced' '
	git checkout conflict1 &&
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		echo X >empty
	) &&
	test_must_fail git merge conflict2 &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.conflict actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a conflicted populated submodule with untracked files fails unless forced' '
	git checkout conflict1 &&
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		echo X >untracked
	) &&
	test_must_fail git merge conflict2 &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.conflict actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a conflicted populated submodule with a .git directory fails even when forced' '
	git checkout conflict1 &&
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		rm .git &&
		cp -R ../.git/modules/sub .git &&
		GIT_WORK_TREE=. git config --unset core.worktree
	) &&
	test_must_fail git merge conflict2 &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -d submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.conflict actual &&
	test_must_fail git rm -f submod &&
	test -d submod &&
	test -d submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.conflict actual &&
	git merge --abort &&
	rm -rf submod
'

test_expect_success 'rm of a conflicted unpopulated submodule succeeds' '
	git checkout conflict1 &&
	git reset --hard &&
	test_must_fail git merge conflict2 &&
	git rm submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated submodule with a .git directory fails even when forced' '
	git checkout -f master &&
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		rm .git &&
		cp -R ../.git/modules/sub .git &&
		GIT_WORK_TREE=. git config --unset core.worktree
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -d submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	! test -s actual &&
	test_must_fail git rm -f submod &&
	test -d submod &&
	test -d submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	! test -s actual &&
	rm -rf submod
'

cat >expect.deepmodified <<EOF
 M submod/subsubmod
EOF

test_expect_success 'setup subsubmodule' '
	git reset --hard &&
	git submodule update &&
	(cd submod &&
		git update-index --add --cacheinfo 160000 $(git rev-parse HEAD) subsubmod &&
		git config -f .gitmodules submodule.sub.url ../. &&
		git config -f .gitmodules submodule.sub.path subsubmod &&
		git submodule init &&
		git add .gitmodules &&
		git commit -m "add subsubmodule" &&
		git submodule update subsubmod
	) &&
	git commit -a -m "added deep submodule"
'

test_expect_success 'rm recursively removes work tree of unmodified submodules' '
	git rm submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated nested submodule with different nested HEAD fails unless forced' '
	git reset --hard &&
	git submodule update --recursive &&
	(cd submod/subsubmod &&
		git checkout HEAD^
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated nested submodule with nested modifications fails unless forced' '
	git reset --hard &&
	git submodule update --recursive &&
	(cd submod/subsubmod &&
		echo X >empty
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated nested submodule with nested untracked files fails unless forced' '
	git reset --hard &&
	git submodule update --recursive &&
	(cd submod/subsubmod &&
		echo X >untracked
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -f submod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect.modified actual &&
	git rm -f submod &&
	test ! -d submod &&
	git status -s -uno --ignore-submodules=none > actual &&
	test_cmp expect actual
'

test_expect_success 'rm of a populated nested submodule with a nested .git directory fails even when forced' '
	git reset --hard &&
	git submodule update --recursive &&
	(cd submod/subsubmod &&
		rm .git &&
		cp -R ../../.git/modules/sub/modules/sub .git &&
		GIT_WORK_TREE=. git config --unset core.worktree
	) &&
	test_must_fail git rm submod &&
	test -d submod &&
	test -d submod/subsubmod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	! test -s actual &&
	test_must_fail git rm -f submod &&
	test -d submod &&
	test -d submod/subsubmod/.git &&
	git status -s -uno --ignore-submodules=none > actual &&
	! test -s actual &&
	rm -rf submod
'

test_expect_success 'rm of d/f when d has become a non-directory' '
	rm -rf d &&
	mkdir d &&
	>d/f &&
	git add d &&
	rm -rf d &&
	>d &&
	git rm d/f &&
	test_must_fail git rev-parse --verify :d/f &&
	test_path_is_file d
'

test_expect_success SYMLINKS 'rm of d/f when d has become a dangling symlink' '
	rm -rf d &&
	mkdir d &&
	>d/f &&
	git add d &&
	rm -rf d &&
	ln -s nonexistent d &&
	git rm d/f &&
	test_must_fail git rev-parse --verify :d/f &&
	test -h d &&
	test_path_is_missing d
'

test_expect_success 'rm of file when it has become a directory' '
	rm -rf d &&
	>d &&
	git add d &&
	rm -f d &&
	mkdir d &&
	>d/f &&
	test_must_fail git rm d &&
	git rev-parse --verify :d &&
	test_path_is_file d/f
'

test_done
Commit	Line	Data
d4a1cab5 CW	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2006 Carl D. Worth
	4	#
	5
5be60078	6	test_description='Test of the various options to git rm.'
d4a1cab5 CW	7
	8	. ./test-lib.sh
	9
3844cdc8	10	# Setup some files to be removed, some with funny characters
22669a04 SP	11	test_expect_success \
	12	'Initialize test directory' \
	13	"touch -- foo bar baz 'space embedded' -q &&
5be60078	14	git add -- foo bar baz 'space embedded' -q &&
56e78bfb JS	15	git commit -m 'add normal files'"
	16
	17	if touch -- 'tab embedded' 'newline
	18	embedded' 2>/dev/null
	19	then
	20	test_set_prereq FUNNYNAMES
	21	else
	22	say 'Your filesystem does not allow tabs in filenames.'
	23	fi
	24
	25	test_expect_success FUNNYNAMES 'add files with funny names' "
5be60078	26	git add -- 'tab embedded' 'newline
22669a04	27	embedded' &&
3604e7c5	28	git commit -m 'add files with tabs and newlines'
56e78bfb	29	"
5b46a428	30
d4a1cab5	31	test_expect_success \
5be60078 JH	32	'Pre-check that foo exists and is in index before git rm foo' \
5be60078 JH	33	'[ -f foo ] && git ls-files --error-unmatch foo'
d4a1cab5 CW	34
d4a1cab5 CW	35	test_expect_success \
5be60078 JH	36	'Test that git rm foo succeeds' \
5be60078 JH	37	'git rm --cached foo'
d4a1cab5	38
bdecd9d4 MM	39	test_expect_success \
	40	'Test that git rm --cached foo succeeds if the index matches the file' \
	41	'echo content > foo
	42	git add foo
	43	git rm --cached foo'
	44
	45	test_expect_success \
	46	'Test that git rm --cached foo succeeds if the index matches the file' \
	47	'echo content > foo
	48	git add foo
	49	git commit -m foo
	50	echo "other content" > foo
	51	git rm --cached foo'
	52
41ac414e JH	53	test_expect_success \
	54	'Test that git rm --cached foo fails if the index matches neither the file nor HEAD' '
	55	echo content > foo
bdecd9d4 MM	56	git add foo
	57	git commit -m foo
	58	echo "other content" > foo
	59	git add foo
	60	echo "yet another content" > foo
d492b31c	61	test_must_fail git rm --cached foo
41ac414e	62	'
bdecd9d4 MM	63
	64	test_expect_success \
	65	'Test that git rm --cached -f foo works in case where --cached only did not' \
	66	'echo content > foo
	67	git add foo
	68	git commit -m foo
	69	echo "other content" > foo
	70	git add foo
	71	echo "yet another content" > foo
	72	git rm --cached -f foo'
	73
3844cdc8	74	test_expect_success \
5be60078	75	'Post-check that foo exists but is not in index after git rm foo' \
d492b31c	76	'[ -f foo ] && test_must_fail git ls-files --error-unmatch foo'
3844cdc8 CW	77
3844cdc8 CW	78	test_expect_success \
5be60078 JH	79	'Pre-check that bar exists and is in index before "git rm bar"' \
5be60078 JH	80	'[ -f bar ] && git ls-files --error-unmatch bar'
d4a1cab5 CW	81
d4a1cab5 CW	82	test_expect_success \
5be60078 JH	83	'Test that "git rm bar" succeeds' \
5be60078 JH	84	'git rm bar'
d4a1cab5	85
3844cdc8	86	test_expect_success \
5be60078	87	'Post-check that bar does not exist and is not in index after "git rm -f bar"' \
d492b31c	88	'! [ -f bar ] && test_must_fail git ls-files --error-unmatch bar'
d4a1cab5 CW	89
d4a1cab5 CW	90	test_expect_success \
5be60078 JH	91	'Test that "git rm -- -q" succeeds (remove a file that looks like an option)' \
5be60078 JH	92	'git rm -- -q'
d4a1cab5	93
56e78bfb	94	test_expect_success FUNNYNAMES \
5be60078 JH	95	"Test that \"git rm -f\" succeeds with embedded space, tab, or newline characters." \
5be60078 JH	96	"git rm -f 'space embedded' 'tab embedded' 'newline
3844cdc8 CW	97	embedded'"
3844cdc8 CW	98
fbbfc8a9	99	test_expect_success SANITY 'Test that "git rm -f" fails if its rm fails' '
56e78bfb JS	100	chmod a-w . &&
	101	test_must_fail git rm -f baz &&
	102	chmod 775 .
	103	'
3844cdc8 CW	104
3844cdc8 CW	105	test_expect_success \
5be60078 JH	106	'When the rm in "git rm -f" fails, it should not remove the file from the index' \
5be60078 JH	107	'git ls-files --error-unmatch baz'
3844cdc8	108
bb1faf0d SG	109	test_expect_success 'Remove nonexistent file with --ignore-unmatch' '
	110	git rm --ignore-unmatch nonexistent
	111	'
	112
b48caa20 SG	113	test_expect_success '"rm" command printed' '
	114	echo frotz > test-file &&
	115	git add test-file &&
	116	git commit -m "add file for rm test" &&
	117	git rm test-file > rm-output &&
0feb4d1c	118	test `grep "^rm " rm-output \| wc -l` = 1 &&
b48caa20 SG	119	rm -f test-file rm-output &&
	120	git commit -m "remove file from rm test"
	121	'
	122
	123	test_expect_success '"rm" command suppressed with --quiet' '
	124	echo frotz > test-file &&
	125	git add test-file &&
	126	git commit -m "add file for rm --quiet test" &&
	127	git rm --quiet test-file > rm-output &&
	128	test `wc -l < rm-output` = 0 &&
	129	rm -f test-file rm-output &&
	130	git commit -m "remove file from rm --quiet test"
	131	'
	132
467e1b53 JH	133	# Now, failure cases.
	134	test_expect_success 'Re-add foo and baz' '
	135	git add foo baz &&
	136	git ls-files --error-unmatch foo baz
	137	'
	138
	139	test_expect_success 'Modify foo -- rm should refuse' '
	140	echo >>foo &&
d492b31c	141	test_must_fail git rm foo baz &&
467e1b53 JH	142	test -f foo &&
	143	test -f baz &&
	144	git ls-files --error-unmatch foo baz
	145	'
	146
	147	test_expect_success 'Modified foo -- rm -f should work' '
	148	git rm -f foo baz &&
	149	test ! -f foo &&
	150	test ! -f baz &&
d492b31c SB	151	test_must_fail git ls-files --error-unmatch foo &&
d492b31c SB	152	test_must_fail git ls-files --error-unmatch bar
467e1b53 JH	153	'
	154
	155	test_expect_success 'Re-add foo and baz for HEAD tests' '
	156	echo frotz >foo &&
	157	git checkout HEAD -- baz &&
	158	git add foo baz &&
	159	git ls-files --error-unmatch foo baz
	160	'
	161
	162	test_expect_success 'foo is different in index from HEAD -- rm should refuse' '
d492b31c	163	test_must_fail git rm foo baz &&
467e1b53 JH	164	test -f foo &&
	165	test -f baz &&
	166	git ls-files --error-unmatch foo baz
	167	'
	168
	169	test_expect_success 'but with -f it should work.' '
	170	git rm -f foo baz &&
	171	test ! -f foo &&
	172	test ! -f baz &&
d492b31c SB	173	test_must_fail git ls-files --error-unmatch foo
d492b31c SB	174	test_must_fail git ls-files --error-unmatch baz
467e1b53 JH	175	'
467e1b53 JH	176
388b2acd JH	177	test_expect_success 'refuse to remove cached empty file with modifications' '
388b2acd JH	178	>empty &&
f55527f8 JK	179	git add empty &&
	180	echo content >empty &&
	181	test_must_fail git rm --cached empty
	182	'
	183
	184	test_expect_success 'remove intent-to-add file without --force' '
	185	echo content >intent-to-add &&
	186	git add -N intent-to-add
	187	git rm --cached intent-to-add
	188	'
	189
467e1b53 JH	190	test_expect_success 'Recursive test setup' '
	191	mkdir -p frotz &&
	192	echo qfwfq >frotz/nitfol &&
	193	git add frotz &&
	194	git commit -m "subdir test"
	195	'
	196
	197	test_expect_success 'Recursive without -r fails' '
d492b31c	198	test_must_fail git rm frotz &&
467e1b53 JH	199	test -d frotz &&
	200	test -f frotz/nitfol
	201	'
	202
	203	test_expect_success 'Recursive with -r but dirty' '
	204	echo qfwfq >>frotz/nitfol
d492b31c	205	test_must_fail git rm -r frotz &&
467e1b53 JH	206	test -d frotz &&
	207	test -f frotz/nitfol
	208	'
	209
	210	test_expect_success 'Recursive with -r -f' '
	211	git rm -f -r frotz &&
	212	! test -f frotz/nitfol &&
	213	! test -d frotz
	214	'
	215
41ac414e	216	test_expect_success 'Remove nonexistent file returns nonzero exit status' '
d492b31c	217	test_must_fail git rm nonexistent
b48caa20 SG	218	'
b48caa20 SG	219
4d264672 OM	220	test_expect_success 'Call "rm" from outside the work tree' '
4d264672 OM	221	mkdir repo &&
cced48a8 JS	222	(cd repo &&
	223	git init &&
	224	echo something > somefile &&
	225	git add somefile &&
	226	git commit -m "add a file" &&
	227	(cd .. &&
	228	git --git-dir=repo/.git --work-tree=repo rm somefile) &&
	229	test_must_fail git ls-files --error-unmatch somefile)
	230	'
	231
	232	test_expect_success 'refresh index before checking if it is up-to-date' '
	233
	234	git reset --hard &&
	235	test-chmtime -86400 frotz/nitfol &&
	236	git rm frotz/nitfol &&
	237	test ! -f frotz/nitfol
	238
4d264672 OM	239	'
4d264672 OM	240
0693f9dd JH	241	test_expect_success 'choking "git rm" should not let it die with cruft' '
0693f9dd JH	242	git reset -q --hard &&
0693f9dd JH	243	i=0 &&
	244	while test $i -lt 12000
	245	do
3749fde5	246	echo "100644 $_z40 0 some-file-$i"
0693f9dd JH	247	i=$(( $i + 1 ))
	248	done \| git update-index --index-info &&
	249	git rm -n "some-file-*" \| :;
	250	test -f .git/index.lock
	251	status=$?
	252	rm -f .git/index.lock
	253	git reset -q --hard
	254	test "$status" != 0
	255	'
	256
3fc0d131 JK	257	test_expect_success 'rm removes subdirectories recursively' '
	258	mkdir -p dir/subdir/subsubdir &&
	259	echo content >dir/subdir/subsubdir/file &&
	260	git add dir/subdir/subsubdir/file &&
	261	git rm -f dir/subdir/subsubdir/file &&
	262	! test -d dir
	263	'
	264
293ab15e JL	265	cat >expect <<EOF
	266	D submod
	267	EOF
	268
	269	cat >expect.modified <<EOF
	270	M submod
	271	EOF
	272
	273	test_expect_success 'rm removes empty submodules from work tree' '
	274	mkdir submod &&
	275	git update-index --add --cacheinfo 160000 $(git rev-parse HEAD) submod &&
	276	git config -f .gitmodules submodule.sub.url ./. &&
	277	git config -f .gitmodules submodule.sub.path submod &&
	278	git submodule init &&
	279	git add .gitmodules &&
	280	git commit -m "add submodule" &&
	281	git rm submod &&
	282	test ! -e submod &&
	283	git status -s -uno --ignore-submodules=none > actual &&
	284	test_cmp expect actual
	285	'
	286
	287	test_expect_success 'rm removes removed submodule from index' '
	288	git reset --hard &&
	289	git submodule update &&
	290	rm -rf submod &&
	291	git rm submod &&
	292	git status -s -uno --ignore-submodules=none > actual &&
	293	test_cmp expect actual
	294	'
	295
	296	test_expect_success 'rm removes work tree of unmodified submodules' '
	297	git reset --hard &&
	298	git submodule update &&
	299	git rm submod &&
	300	test ! -d submod &&
	301	git status -s -uno --ignore-submodules=none > actual &&
	302	test_cmp expect actual
	303	'
	304
53e4c5dc JL	305	test_expect_success 'rm removes a submodule with a trailing /' '
	306	git reset --hard &&
	307	git submodule update &&
	308	git rm submod/ &&
	309	test ! -d submod &&
	310	git status -s -uno --ignore-submodules=none > actual &&
	311	test_cmp expect actual
	312	'
	313
	314	test_expect_success 'rm fails when given a file with a trailing /' '
	315	test_must_fail git rm empty/
	316	'
	317
	318	test_expect_success 'rm succeeds when given a directory with a trailing /' '
	319	git rm -r frotz/
	320	'
	321
293ab15e JL	322	test_expect_success 'rm of a populated submodule with different HEAD fails unless forced' '
	323	git reset --hard &&
	324	git submodule update &&
	325	(cd submod &&
	326	git checkout HEAD^
	327	) &&
	328	test_must_fail git rm submod &&
	329	test -d submod &&
	330	test -f submod/.git &&
	331	git status -s -uno --ignore-submodules=none > actual &&
	332	test_cmp expect.modified actual &&
	333	git rm -f submod &&
	334	test ! -d submod &&
	335	git status -s -uno --ignore-submodules=none > actual &&
	336	test_cmp expect actual
	337	'
	338
	339	test_expect_success 'rm of a populated submodule with modifications fails unless forced' '
	340	git reset --hard &&
	341	git submodule update &&
	342	(cd submod &&
	343	echo X >empty
	344	) &&
	345	test_must_fail git rm submod &&
	346	test -d submod &&
	347	test -f submod/.git &&
	348	git status -s -uno --ignore-submodules=none > actual &&
	349	test_cmp expect.modified actual &&
	350	git rm -f submod &&
	351	test ! -d submod &&
	352	git status -s -uno --ignore-submodules=none > actual &&
	353	test_cmp expect actual
	354	'
	355
	356	test_expect_success 'rm of a populated submodule with untracked files fails unless forced' '
	357	git reset --hard &&
	358	git submodule update &&
	359	(cd submod &&
	360	echo X >untracked
	361	) &&
	362	test_must_fail git rm submod &&
	363	test -d submod &&
	364	test -f submod/.git &&
	365	git status -s -uno --ignore-submodules=none > actual &&
	366	test_cmp expect.modified actual &&
	367	git rm -f submod &&
	368	test ! -d submod &&
	369	git status -s -uno --ignore-submodules=none > actual &&
	370	test_cmp expect actual
	371	'
	372
	373	test_expect_success 'setup submodule conflict' '
	374	git reset --hard &&
	375	git submodule update &&
	376	git checkout -b branch1 &&
	377	echo 1 >nitfol &&
	378	git add nitfol &&
	379	git commit -m "added nitfol 1" &&
	380	git checkout -b branch2 master &&
	381	echo 2 >nitfol &&
	382	git add nitfol &&
	383	git commit -m "added nitfol 2" &&
	384	git checkout -b conflict1 master &&
	385	(cd submod &&
386	git fetch &&
387	git checkout branch1
388	) &&
389	git add submod &&
390	git commit -m "submod 1" &&
391	git checkout -b conflict2 master &&
392	(cd submod &&
393	git checkout branch2
394	) &&
395	git add submod &&
396	git commit -m "submod 2"
397	'
398
399	cat >expect.conflict <<EOF
400	UU submod
401	EOF
402
403	test_expect_success 'rm removes work tree of unmodified conflicted submodule' '
404	git checkout conflict1 &&
405	git reset --hard &&
406	git submodule update &&
407	test_must_fail git merge conflict2 &&
408	git rm submod &&
409	test ! -d submod &&
410	git status -s -uno --ignore-submodules=none > actual &&
411	test_cmp expect actual
412	'
413
414	test_expect_success 'rm of a conflicted populated submodule with different HEAD fails unless forced' '
415	git checkout conflict1 &&
416	git reset --hard &&
417	git submodule update &&
418	(cd submod &&
419	git checkout HEAD^
420	) &&
421	test_must_fail git merge conflict2 &&
422	test_must_fail git rm submod &&
423	test -d submod &&
424	test -f submod/.git &&
425	git status -s -uno --ignore-submodules=none > actual &&
426	test_cmp expect.conflict actual &&
427	git rm -f submod &&
428	test ! -d submod &&
429	git status -s -uno --ignore-submodules=none > actual &&
430	test_cmp expect actual
431	'
432
433	test_expect_success 'rm of a conflicted populated submodule with modifications fails unless forced' '
434	git checkout conflict1 &&
435	git reset --hard &&
436	git submodule update &&
437	(cd submod &&
438	echo X >empty
439	) &&
440	test_must_fail git merge conflict2 &&
441	test_must_fail git rm submod &&
442	test -d submod &&
443	test -f submod/.git &&
444	git status -s -uno --ignore-submodules=none > actual &&
445	test_cmp expect.conflict actual &&
446	git rm -f submod &&
447	test ! -d submod &&
448	git status -s -uno --ignore-submodules=none > actual &&
449	test_cmp expect actual
450	'
451
452	test_expect_success 'rm of a conflicted populated submodule with untracked files fails unless forced' '
453	git checkout conflict1 &&
454	git reset --hard &&
455	git submodule update &&
456	(cd submod &&
457	echo X >untracked
458	) &&
459	test_must_fail git merge conflict2 &&
460	test_must_fail git rm submod &&
461	test -d submod &&
462	test -f submod/.git &&
463	git status -s -uno --ignore-submodules=none > actual &&
464	test_cmp expect.conflict actual &&
465	git rm -f submod &&
466	test ! -d submod &&
467	git status -s -uno --ignore-submodules=none > actual &&
468	test_cmp expect actual
469	'
470
471	test_expect_success 'rm of a conflicted populated submodule with a .git directory fails even when forced' '
472	git checkout conflict1 &&
473	git reset --hard &&
474	git submodule update &&
475	(cd submod &&
476	rm .git &&
2d3ac9ad	477	cp -R ../.git/modules/sub .git &&
293ab15e JL	478	GIT_WORK_TREE=. git config --unset core.worktree
	479	) &&
	480	test_must_fail git merge conflict2 &&
	481	test_must_fail git rm submod &&
	482	test -d submod &&
	483	test -d submod/.git &&
	484	git status -s -uno --ignore-submodules=none > actual &&
	485	test_cmp expect.conflict actual &&
	486	test_must_fail git rm -f submod &&
	487	test -d submod &&
	488	test -d submod/.git &&
	489	git status -s -uno --ignore-submodules=none > actual &&
	490	test_cmp expect.conflict actual &&
	491	git merge --abort &&
	492	rm -rf submod
	493	'
	494
	495	test_expect_success 'rm of a conflicted unpopulated submodule succeeds' '
	496	git checkout conflict1 &&
	497	git reset --hard &&
	498	test_must_fail git merge conflict2 &&
	499	git rm submod &&
	500	test ! -d submod &&
	501	git status -s -uno --ignore-submodules=none > actual &&
	502	test_cmp expect actual
	503	'
	504
	505	test_expect_success 'rm of a populated submodule with a .git directory fails even when forced' '
	506	git checkout -f master &&
	507	git reset --hard &&
	508	git submodule update &&
	509	(cd submod &&
	510	rm .git &&
2d3ac9ad	511	cp -R ../.git/modules/sub .git &&
293ab15e JL	512	GIT_WORK_TREE=. git config --unset core.worktree
	513	) &&
	514	test_must_fail git rm submod &&
	515	test -d submod &&
	516	test -d submod/.git &&
	517	git status -s -uno --ignore-submodules=none > actual &&
	518	! test -s actual &&
	519	test_must_fail git rm -f submod &&
	520	test -d submod &&
	521	test -d submod/.git &&
	522	git status -s -uno --ignore-submodules=none > actual &&
	523	! test -s actual &&
	524	rm -rf submod
	525	'
	526
	527	cat >expect.deepmodified <<EOF
	528	M submod/subsubmod
	529	EOF
	530
	531	test_expect_success 'setup subsubmodule' '
	532	git reset --hard &&
	533	git submodule update &&
	534	(cd submod &&
	535	git update-index --add --cacheinfo 160000 $(git rev-parse HEAD) subsubmod &&
	536	git config -f .gitmodules submodule.sub.url ../. &&
	537	git config -f .gitmodules submodule.sub.path subsubmod &&
	538	git submodule init &&
	539	git add .gitmodules &&
	540	git commit -m "add subsubmodule" &&
	541	git submodule update subsubmod
	542	) &&
	543	git commit -a -m "added deep submodule"
	544	'
	545
	546	test_expect_success 'rm recursively removes work tree of unmodified submodules' '
	547	git rm submod &&
	548	test ! -d submod &&
	549	git status -s -uno --ignore-submodules=none > actual &&
	550	test_cmp expect actual
	551	'
	552
	553	test_expect_success 'rm of a populated nested submodule with different nested HEAD fails unless forced' '
	554	git reset --hard &&
	555	git submodule update --recursive &&
	556	(cd submod/subsubmod &&
	557	git checkout HEAD^
	558	) &&
	559	test_must_fail git rm submod &&
	560	test -d submod &&
	561	test -f submod/.git &&
	562	git status -s -uno --ignore-submodules=none > actual &&
	563	test_cmp expect.modified actual &&
	564	git rm -f submod &&
	565	test ! -d submod &&
	566	git status -s -uno --ignore-submodules=none > actual &&
	567	test_cmp expect actual
	568	'
	569
	570	test_expect_success 'rm of a populated nested submodule with nested modifications fails unless forced' '
	571	git reset --hard &&
	572	git submodule update --recursive &&
	573	(cd submod/subsubmod &&
	574	echo X >empty
	575	) &&
576	test_must_fail git rm submod &&
577	test -d submod &&
578	test -f submod/.git &&
579	git status -s -uno --ignore-submodules=none > actual &&
580	test_cmp expect.modified actual &&
581	git rm -f submod &&
582	test ! -d submod &&
583	git status -s -uno --ignore-submodules=none > actual &&
584	test_cmp expect actual
585	'
586
587	test_expect_success 'rm of a populated nested submodule with nested untracked files fails unless forced' '
588	git reset --hard &&
589	git submodule update --recursive &&
590	(cd submod/subsubmod &&
591	echo X >untracked
592	) &&
593	test_must_fail git rm submod &&
594	test -d submod &&
595	test -f submod/.git &&
596	git status -s -uno --ignore-submodules=none > actual &&
597	test_cmp expect.modified actual &&
598	git rm -f submod &&
599	test ! -d submod &&
600	git status -s -uno --ignore-submodules=none > actual &&
601	test_cmp expect actual
602	'
603
604	test_expect_success 'rm of a populated nested submodule with a nested .git directory fails even when forced' '
605	git reset --hard &&
606	git submodule update --recursive &&
607	(cd submod/subsubmod &&
608	rm .git &&
2d3ac9ad	609	cp -R ../../.git/modules/sub/modules/sub .git &&
293ab15e JL	610	GIT_WORK_TREE=. git config --unset core.worktree
	611	) &&
	612	test_must_fail git rm submod &&
	613	test -d submod &&
	614	test -d submod/subsubmod/.git &&
	615	git status -s -uno --ignore-submodules=none > actual &&
	616	! test -s actual &&
	617	test_must_fail git rm -f submod &&
	618	test -d submod &&
	619	test -d submod/subsubmod/.git &&
	620	git status -s -uno --ignore-submodules=none > actual &&
	621	! test -s actual &&
	622	rm -rf submod
	623	'
	624
9a6728d4 JK	625	test_expect_success 'rm of d/f when d has become a non-directory' '
	626	rm -rf d &&
	627	mkdir d &&
	628	>d/f &&
	629	git add d &&
	630	rm -rf d &&
	631	>d &&
	632	git rm d/f &&
	633	test_must_fail git rev-parse --verify :d/f &&
	634	test_path_is_file d
	635	'
	636
	637	test_expect_success SYMLINKS 'rm of d/f when d has become a dangling symlink' '
	638	rm -rf d &&
	639	mkdir d &&
	640	>d/f &&
	641	git add d &&
	642	rm -rf d &&
	643	ln -s nonexistent d &&
	644	git rm d/f &&
	645	test_must_fail git rev-parse --verify :d/f &&
	646	test -h d &&
	647	test_path_is_missing d
	648	'
	649
96ec8ee9 JK	650	test_expect_success 'rm of file when it has become a directory' '
	651	rm -rf d &&
	652	>d &&
	653	git add d &&
	654	rm -f d &&
	655	mkdir d &&
	656	>d/f &&
	657	test_must_fail git rm d &&
	658	git rev-parse --verify :d &&
	659	test_path_is_file d/f
	660	'
	661
d4a1cab5	662	test_done