#!/bin/sh

global test_description := ''git mv in subdirs''
source ./test-lib.sh

test_expect_success \
    'prepare reference tree' \
    'mkdir path0 path1 &&
     cp "$TEST_DIRECTORY"/../COPYING path0/COPYING &&
     git add path0/COPYING &&
     git commit -m add -a'

test_expect_success \
    'moving the file out of subdirectory' \
    'cd path0 && git mv COPYING ../path1/COPYING'

# in path0 currently
test_expect_success \
    'commiting the change' \
    'cd .. && git commit -m move-out -a'

test_expect_success \
    'checking the commit' \
    'git diff-tree -r -M --name-status  HEAD^ HEAD | \
    grep "^R100..*path0/COPYING..*path1/COPYING"'

test_expect_success \
    'moving the file back into subdirectory' \
    'cd path0 && git mv ../path1/COPYING COPYING'

# in path0 currently
test_expect_success \
    'commiting the change' \
    'cd .. && git commit -m move-in -a'

test_expect_success \
    'checking the commit' \
    'git diff-tree -r -M --name-status  HEAD^ HEAD | \
    grep "^R100..*path1/COPYING..*path0/COPYING"'

test_expect_success \
    'checking -k on non-existing file' \
    'git mv -k idontexist path0'

test_expect_success \
    'checking -k on untracked file' \
    'touch untracked1 &&
     git mv -k untracked1 path0 &&
     test -f untracked1 &&
     test ! -f path0/untracked1'

test_expect_success \
    'checking -k on multiple untracked files' \
    'touch untracked2 &&
     git mv -k untracked1 untracked2 path0 &&
     test -f untracked1 &&
     test -f untracked2 &&
     test ! -f path0/untracked1 &&
     test ! -f path0/untracked2'

test_expect_success \
    'checking -f on untracked file with existing target' \
    'touch path0/untracked1 &&
     test_must_fail git mv -f untracked1 path0 &&
     test ! -f .git/index.lock &&
     test -f untracked1 &&
     test -f path0/untracked1'

# clean up the mess in case bad things happen
rm -f idontexist untracked1 untracked2 \
     path0/idontexist path0/untracked1 path0/untracked2 \
     .git/index.lock
rmdir path1

test_expect_success \
    'moving to absent target with trailing slash' \
    'test_must_fail git mv path0/COPYING no-such-dir/ &&
     test_must_fail git mv path0/COPYING no-such-dir// &&
     git mv path0/ no-such-dir/ &&
     test_path_is_dir no-such-dir'

test_expect_success \
    'clean up' \
    'git reset --hard'

test_expect_success \
    'moving to existing untracked target with trailing slash' \
    'mkdir path1 &&
     git mv path0/ path1/ &&
     test_path_is_dir path1/path0/'

test_expect_success \
    'moving to existing tracked target with trailing slash' \
    'mkdir path2 &&
     >path2/file && git add path2/file &&
     git mv path1/path0/ path2/ &&
     test_path_is_dir path2/path0/'

test_expect_success \
    'clean up' \
    'git reset --hard'

test_expect_success \
    'adding another file' \
    'cp "$TEST_DIRECTORY"/../README.md path0/README &&
     git add path0/README &&
     git commit -m add2 -a'

test_expect_success \
    'moving whole subdirectory' \
    'git mv path0 path2'

test_expect_success \
    'commiting the change' \
    'git commit -m dir-move -a'

test_expect_success \
    'checking the commit' \
    'git diff-tree -r -M --name-status  HEAD^ HEAD | \
     grep "^R100..*path0/COPYING..*path2/COPYING" &&
     git diff-tree -r -M --name-status  HEAD^ HEAD | \
     grep "^R100..*path0/README..*path2/README"'

test_expect_success \
    'succeed when source is a prefix of destination' \
    'git mv path2/COPYING path2/COPYING-renamed'

test_expect_success \
    'moving whole subdirectory into subdirectory' \
    'git mv path2 path1'

test_expect_success \
    'commiting the change' \
    'git commit -m dir-move -a'

test_expect_success \
    'checking the commit' \
    'git diff-tree -r -M --name-status  HEAD^ HEAD | \
     grep "^R100..*path2/COPYING..*path1/path2/COPYING" &&
     git diff-tree -r -M --name-status  HEAD^ HEAD | \
     grep "^R100..*path2/README..*path1/path2/README"'

test_expect_success \
    'do not move directory over existing directory' \
    'mkdir path0 && mkdir path0/path2 && test_must_fail git mv path2 path0'

test_expect_success \
    'move into "."' \
    'git mv path1/path2/ .'

test_expect_success "Michael Cassar's test case" '
	rm -fr .git papers partA &&
	git init &&
	mkdir -p papers/unsorted papers/all-papers partA &&
	echo a > papers/unsorted/Thesis.pdf &&
	echo b > partA/outline.txt &&
	echo c > papers/unsorted/_another &&
	git add papers partA &&
	T1=$(git write-tree) &&

	git mv papers/unsorted/Thesis.pdf papers/all-papers/moo-blah.pdf &&

	T=$(git write-tree) &&
	git ls-tree -r $T | verbose grep partA/outline.txt
'

rm -fr papers partA path?

test_expect_success "Sergey Vlasov's test case" '
	rm -fr .git &&
	git init &&
	mkdir ab &&
	date >ab.c &&
	date >ab/d &&
	git add ab.c ab &&
	git commit -m 'initial' &&
	git mv ab a
'

test_expect_success 'absolute pathname' '(

	rm -fr mine &&
	mkdir mine &&
	cd mine &&
	test_create_repo one &&
	cd one &&
	mkdir sub &&
	>sub/file &&
	git add sub/file &&

	git mv sub "$(pwd)/in" &&
	! test -d sub &&
	test -d in &&
	git ls-files --error-unmatch in/file


)'

test_expect_success 'absolute pathname outside should fail' '(

	rm -fr mine &&
	mkdir mine &&
	cd mine &&
	out=$(pwd) &&
	test_create_repo one &&
	cd one &&
	mkdir sub &&
	>sub/file &&
	git add sub/file &&

	test_must_fail git mv sub "$out/out" &&
	test -d sub &&
	! test -d ../in &&
	git ls-files --error-unmatch sub/file

)'

test_expect_success 'git mv to move multiple sources into a directory' '
	rm -fr .git && git init &&
	mkdir dir other &&
	>dir/a.txt &&
	>dir/b.txt &&
	git add dir/?.txt &&
	git mv dir/a.txt dir/b.txt other &&
	git ls-files >actual &&
	{ echo other/a.txt; echo other/b.txt; } >expect &&
	test_cmp expect actual
'

test_expect_success 'git mv should not change sha1 of moved cache entry' '

	rm -fr .git &&
	git init &&
	echo 1 >dirty &&
	git add dirty &&
	entry="$(git ls-files --stage dirty | cut -f 1)" &&
	git mv dirty dirty2 &&
	[ "$entry" = "$(git ls-files --stage dirty2 | cut -f 1)" ] &&
	echo 2 >dirty2 &&
	git mv dirty2 dirty &&
	[ "$entry" = "$(git ls-files --stage dirty | cut -f 1)" ]

'

rm -f dirty dirty2

test_expect_success 'git mv should overwrite symlink to a file' '

	rm -fr .git &&
	git init &&
	echo 1 >moved &&
	test_ln_s_add moved symlink &&
	git add moved &&
	test_must_fail git mv moved symlink &&
	git mv -f moved symlink &&
	! test -e moved &&
	test -f symlink &&
	test "$(cat symlink)" = 1 &&
	git update-index --refresh &&
	git diff-files --quiet

'

rm -f moved symlink

test_expect_success 'git mv should overwrite file with a symlink' '

	rm -fr .git &&
	git init &&
	echo 1 >moved &&
	test_ln_s_add moved symlink &&
	git add moved &&
	test_must_fail git mv symlink moved &&
	git mv -f symlink moved &&
	! test -e symlink &&
	git update-index --refresh &&
	git diff-files --quiet

'

test_expect_success SYMLINKS 'check moved symlink' '

	test -h moved
'

rm -f moved symlink

test_expect_success 'setup submodule' '
	git commit -m initial &&
	git reset --hard &&
	git submodule add ./. sub &&
	echo content >file &&
	git add file &&
	git commit -m "added sub and file" &&
	mkdir -p deep/directory/hierarchy &&
	git submodule add ./. deep/directory/hierarchy/sub &&
	git commit -m "added another submodule" &&
	git branch submodule
'

test_expect_success 'git mv cannot move a submodule in a file' '
	test_must_fail git mv sub file
'

test_expect_success 'git mv moves a submodule with a .git directory and no .gitmodules' '
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	git rm .gitmodules &&
	(
		cd sub &&
		rm -f .git &&
		cp -R -P -p ../.git/modules/sub .git &&
		GIT_WORK_TREE=. git config --unset core.worktree
	) &&
	mkdir mod &&
	git mv sub mod/sub &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'git mv moves a submodule with a .git directory and .gitmodules' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	(
		cd sub &&
		rm -f .git &&
		cp -R -P -p ../.git/modules/sub .git &&
		GIT_WORK_TREE=. git config --unset core.worktree
	) &&
	mkdir mod &&
	git mv sub mod/sub &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	echo mod/sub >expected &&
	git config -f .gitmodules submodule.sub.path >actual &&
	test_cmp expected actual &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'git mv moves a submodule with gitfile' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	mkdir mod &&
	(
		cd mod &&
		git mv ../sub/ .
	) &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	echo mod/sub >expected &&
	git config -f .gitmodules submodule.sub.path >actual &&
	test_cmp expected actual &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'mv does not complain when no .gitmodules file is found' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	git rm .gitmodules &&
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	mkdir mod &&
	git mv sub mod/sub 2>actual.err &&
	! test -s actual.err &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'mv will error out on a modified .gitmodules file unless staged' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	git config -f .gitmodules foo.bar true &&
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	mkdir mod &&
	test_must_fail git mv sub mod/sub 2>actual.err &&
	test -s actual.err &&
	test -e sub &&
	git diff-files --quiet -- sub &&
	git add .gitmodules &&
	git mv sub mod/sub 2>actual.err &&
	! test -s actual.err &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'mv issues a warning when section is not found in .gitmodules' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	git config -f .gitmodules --remove-section submodule.sub &&
	git add .gitmodules &&
	entry="$(git ls-files --stage sub | cut -f 1)" &&
	echo "warning: Could not find section in .gitmodules where path=sub" >expect.err &&
	mkdir mod &&
	git mv sub mod/sub 2>actual.err &&
	test_i18ncmp expect.err actual.err &&
	! test -e sub &&
	[ "$entry" = "$(git ls-files --stage mod/sub | cut -f 1)" ] &&
	(
		cd mod/sub &&
		git status
	) &&
	git update-index --refresh &&
	git diff-files --quiet
'

test_expect_success 'mv --dry-run does not touch the submodule or .gitmodules' '
	rm -rf mod &&
	git reset --hard &&
	git submodule update &&
	mkdir mod &&
	git mv -n sub mod/sub 2>actual.err &&
	test -f sub/.git &&
	git diff-index --exit-code HEAD &&
	git update-index --refresh &&
	git diff-files --quiet -- sub .gitmodules
'

test_expect_success 'checking out a commit before submodule moved needs manual updates' '
	git mv sub sub2 &&
	git commit -m "moved sub to sub2" &&
	git checkout -q HEAD^ 2>actual &&
	test_i18ngrep "^warning: unable to rmdir sub2:" actual &&
	git status -s sub2 >actual &&
	echo "?? sub2/" >expected &&
	test_cmp expected actual &&
	! test -f sub/.git &&
	test -f sub2/.git &&
	git submodule update &&
	test -f sub/.git &&
	rm -rf sub2 &&
	git diff-index --exit-code HEAD &&
	git update-index --refresh &&
	git diff-files --quiet -- sub .gitmodules &&
	git status -s sub2 >actual &&
	! test -s actual
'

test_expect_success 'mv -k does not accidentally destroy submodules' '
	git checkout submodule &&
	mkdir dummy dest &&
	git mv -k dummy sub dest &&
	git status --porcelain >actual &&
	grep "^R  sub -> dest/sub" actual &&
	git reset --hard &&
	git checkout .
'

test_expect_success 'moving a submodule in nested directories' '
	(
		cd deep &&
		git mv directory ../ &&
		# git status would fail if the update of linking git dir to
		# work dir of the submodule failed.
		git status &&
		git config -f ../.gitmodules submodule.deep/directory/hierarchy/sub.path >../actual &&
		echo "directory/hierarchy/sub" >../expect
	) &&
	test_cmp actual expect
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"git mv in subdirs">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (C {(test_expect_success)} {(SQ <"prepare reference tree">)} 
      {
        (SQ <"mkdir path0 path1 &&\n"> <"     cp \"$TEST_DIRECTORY\"/../COPYING path0/COPYING &&\n"> 
          <"     git add path0/COPYING &&\n"> <"     git commit -m add -a">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"moving the file out of subdirectory">)} 
      {(SQ <"cd path0 && git mv COPYING ../path1/COPYING">)}
    )
    (C {(test_expect_success)} {(SQ <"commiting the change">)} 
      {(SQ <"cd .. && git commit -m move-out -a">)}
    )
    (C {(test_expect_success)} {(SQ <"checking the commit">)} 
      {
        (SQ <"git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"    grep \"^R100..*path0/COPYING..*path1/COPYING\"">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"moving the file back into subdirectory">)} 
      {(SQ <"cd path0 && git mv ../path1/COPYING COPYING">)}
    )
    (C {(test_expect_success)} {(SQ <"commiting the change">)} 
      {(SQ <"cd .. && git commit -m move-in -a">)}
    )
    (C {(test_expect_success)} {(SQ <"checking the commit">)} 
      {
        (SQ <"git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"    grep \"^R100..*path1/COPYING..*path0/COPYING\"">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"checking -k on non-existing file">)} 
      {(SQ <"git mv -k idontexist path0">)}
    )
    (C {(test_expect_success)} {(SQ <"checking -k on untracked file">)} 
      {
        (SQ <"touch untracked1 &&\n"> <"     git mv -k untracked1 path0 &&\n"> 
          <"     test -f untracked1 &&\n"> <"     test ! -f path0/untracked1">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"checking -k on multiple untracked files">)} 
      {
        (SQ <"touch untracked2 &&\n"> <"     git mv -k untracked1 untracked2 path0 &&\n"> 
          <"     test -f untracked1 &&\n"> <"     test -f untracked2 &&\n"> <"     test ! -f path0/untracked1 &&\n"> 
          <"     test ! -f path0/untracked2">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"checking -f on untracked file with existing target">)} 
      {
        (SQ <"touch path0/untracked1 &&\n"> <"     test_must_fail git mv -f untracked1 path0 &&\n"> 
          <"     test ! -f .git/index.lock &&\n"> <"     test -f untracked1 &&\n"> <"     test -f path0/untracked1">
        )
      }
    )
    (C {(rm)} {(-f)} {(idontexist)} {(untracked1)} {(untracked2)} {(path0/idontexist)} {(path0/untracked1)} 
      {(path0/untracked2)} {(.git/index.lock)}
    )
    (C {(rmdir)} {(path1)})
    (C {(test_expect_success)} {(SQ <"moving to absent target with trailing slash">)} 
      {
        (SQ <"test_must_fail git mv path0/COPYING no-such-dir/ &&\n"> 
          <"     test_must_fail git mv path0/COPYING no-such-dir// &&\n"> <"     git mv path0/ no-such-dir/ &&\n"> <"     test_path_is_dir no-such-dir">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"clean up">)} {(SQ <"git reset --hard">)})
    (C {(test_expect_success)} {(SQ <"moving to existing untracked target with trailing slash">)} 
      {
        (SQ <"mkdir path1 &&\n"> <"     git mv path0/ path1/ &&\n"> 
          <"     test_path_is_dir path1/path0/">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"moving to existing tracked target with trailing slash">)} 
      {
        (SQ <"mkdir path2 &&\n"> <"     >path2/file && git add path2/file &&\n"> 
          <"     git mv path1/path0/ path2/ &&\n"> <"     test_path_is_dir path2/path0/">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"clean up">)} {(SQ <"git reset --hard">)})
    (C {(test_expect_success)} {(SQ <"adding another file">)} 
      {
        (SQ <"cp \"$TEST_DIRECTORY\"/../README.md path0/README &&\n"> 
          <"     git add path0/README &&\n"> <"     git commit -m add2 -a">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"moving whole subdirectory">)} {(SQ <"git mv path0 path2">)})
    (C {(test_expect_success)} {(SQ <"commiting the change">)} {(SQ <"git commit -m dir-move -a">)})
    (C {(test_expect_success)} {(SQ <"checking the commit">)} 
      {
        (SQ <"git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"     grep \"^R100..*path0/COPYING..*path2/COPYING\" &&\n"> <"     git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"     grep \"^R100..*path0/README..*path2/README\"">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"succeed when source is a prefix of destination">)} 
      {(SQ <"git mv path2/COPYING path2/COPYING-renamed">)}
    )
    (C {(test_expect_success)} {(SQ <"moving whole subdirectory into subdirectory">)} 
      {(SQ <"git mv path2 path1">)}
    )
    (C {(test_expect_success)} {(SQ <"commiting the change">)} {(SQ <"git commit -m dir-move -a">)})
    (C {(test_expect_success)} {(SQ <"checking the commit">)} 
      {
        (SQ <"git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"     grep \"^R100..*path2/COPYING..*path1/path2/COPYING\" &&\n"> <"     git diff-tree -r -M --name-status  HEAD^ HEAD | \\\n"> 
          <"     grep \"^R100..*path2/README..*path1/path2/README\"">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"do not move directory over existing directory">)} 
      {(SQ <"mkdir path0 && mkdir path0/path2 && test_must_fail git mv path2 path0">)}
    )
    (C {(test_expect_success)} {(SQ <"move into \".\"">)} {(SQ <"git mv path1/path2/ .">)})
    (C {(test_expect_success)} {(DQ ("Michael Cassar's test case"))} 
      {
        (SQ <"\n"> <"\trm -fr .git papers partA &&\n"> <"\tgit init &&\n"> 
          <"\tmkdir -p papers/unsorted papers/all-papers partA &&\n"> <"\techo a > papers/unsorted/Thesis.pdf &&\n"> <"\techo b > partA/outline.txt &&\n"> 
          <"\techo c > papers/unsorted/_another &&\n"> <"\tgit add papers partA &&\n"> <"\tT1=$(git write-tree) &&\n"> <"\n"> 
          <"\tgit mv papers/unsorted/Thesis.pdf papers/all-papers/moo-blah.pdf &&\n"> <"\n"> <"\tT=$(git write-tree) &&\n"> <"\tgit ls-tree -r $T | verbose grep partA/outline.txt\n">
        )
      }
    )
    (C {(rm)} {(-fr)} {(papers)} {(partA)} {(path) (Lit_Other "?")})
    (C {(test_expect_success)} {(DQ ("Sergey Vlasov's test case"))} 
      {
        (SQ <"\n"> <"\trm -fr .git &&\n"> <"\tgit init &&\n"> <"\tmkdir ab &&\n"> <"\tdate >ab.c &&\n"> 
          <"\tdate >ab/d &&\n"> <"\tgit add ab.c ab &&\n"> <"\tgit commit -m ">
        ) (initial) (SQ <" &&\n"> <"\tgit mv ab a\n">)
      }
    )
    (C {(test_expect_success)} {(SQ <"absolute pathname">)} 
      {
        (SQ <"(\n"> <"\n"> <"\trm -fr mine &&\n"> <"\tmkdir mine &&\n"> <"\tcd mine &&\n"> 
          <"\ttest_create_repo one &&\n"> <"\tcd one &&\n"> <"\tmkdir sub &&\n"> <"\t>sub/file &&\n"> <"\tgit add sub/file &&\n"> <"\n"> 
          <"\tgit mv sub \"$(pwd)/in\" &&\n"> <"\t! test -d sub &&\n"> <"\ttest -d in &&\n"> <"\tgit ls-files --error-unmatch in/file\n"> <"\n"> <"\n"> 
          <")">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"absolute pathname outside should fail">)} 
      {
        (SQ <"(\n"> <"\n"> <"\trm -fr mine &&\n"> <"\tmkdir mine &&\n"> <"\tcd mine &&\n"> 
          <"\tout=$(pwd) &&\n"> <"\ttest_create_repo one &&\n"> <"\tcd one &&\n"> <"\tmkdir sub &&\n"> <"\t>sub/file &&\n"> 
          <"\tgit add sub/file &&\n"> <"\n"> <"\ttest_must_fail git mv sub \"$out/out\" &&\n"> <"\ttest -d sub &&\n"> 
          <"\t! test -d ../in &&\n"> <"\tgit ls-files --error-unmatch sub/file\n"> <"\n"> <")">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git mv to move multiple sources into a directory">)} 
      {
        (SQ <"\n"> <"\trm -fr .git && git init &&\n"> <"\tmkdir dir other &&\n"> <"\t>dir/a.txt &&\n"> 
          <"\t>dir/b.txt &&\n"> <"\tgit add dir/?.txt &&\n"> <"\tgit mv dir/a.txt dir/b.txt other &&\n"> 
          <"\tgit ls-files >actual &&\n"> <"\t{ echo other/a.txt; echo other/b.txt; } >expect &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git mv should not change sha1 of moved cache entry">)} 
      {
        (SQ <"\n"> <"\n"> <"\trm -fr .git &&\n"> <"\tgit init &&\n"> <"\techo 1 >dirty &&\n"> 
          <"\tgit add dirty &&\n"> <"\tentry=\"$(git ls-files --stage dirty | cut -f 1)\" &&\n"> <"\tgit mv dirty dirty2 &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage dirty2 | cut -f 1)\" ] &&\n"> <"\techo 2 >dirty2 &&\n"> <"\tgit mv dirty2 dirty &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage dirty | cut -f 1)\" ]\n"> <"\n">
        )
      }
    )
    (C {(rm)} {(-f)} {(dirty)} {(dirty2)})
    (C {(test_expect_success)} {(SQ <"git mv should overwrite symlink to a file">)} 
      {
        (SQ <"\n"> <"\n"> <"\trm -fr .git &&\n"> <"\tgit init &&\n"> <"\techo 1 >moved &&\n"> 
          <"\ttest_ln_s_add moved symlink &&\n"> <"\tgit add moved &&\n"> <"\ttest_must_fail git mv moved symlink &&\n"> 
          <"\tgit mv -f moved symlink &&\n"> <"\t! test -e moved &&\n"> <"\ttest -f symlink &&\n"> <"\ttest \"$(cat symlink)\" = 1 &&\n"> 
          <"\tgit update-index --refresh &&\n"> <"\tgit diff-files --quiet\n"> <"\n">
        )
      }
    )
    (C {(rm)} {(-f)} {(moved)} {(symlink)})
    (C {(test_expect_success)} {(SQ <"git mv should overwrite file with a symlink">)} 
      {
        (SQ <"\n"> <"\n"> <"\trm -fr .git &&\n"> <"\tgit init &&\n"> <"\techo 1 >moved &&\n"> 
          <"\ttest_ln_s_add moved symlink &&\n"> <"\tgit add moved &&\n"> <"\ttest_must_fail git mv symlink moved &&\n"> 
          <"\tgit mv -f symlink moved &&\n"> <"\t! test -e symlink &&\n"> <"\tgit update-index --refresh &&\n"> <"\tgit diff-files --quiet\n"> <"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SYMLINKS)} {(SQ <"check moved symlink">)} 
      {(SQ <"\n"> <"\n"> <"\ttest -h moved\n">)}
    )
    (C {(rm)} {(-f)} {(moved)} {(symlink)})
    (C {(test_expect_success)} {(SQ <"setup submodule">)} 
      {
        (SQ <"\n"> <"\tgit commit -m initial &&\n"> <"\tgit reset --hard &&\n"> 
          <"\tgit submodule add ./. sub &&\n"> <"\techo content >file &&\n"> <"\tgit add file &&\n"> <"\tgit commit -m \"added sub and file\" &&\n"> 
          <"\tmkdir -p deep/directory/hierarchy &&\n"> <"\tgit submodule add ./. deep/directory/hierarchy/sub &&\n"> 
          <"\tgit commit -m \"added another submodule\" &&\n"> <"\tgit branch submodule\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git mv cannot move a submodule in a file">)} 
      {(SQ <"\n"> <"\ttest_must_fail git mv sub file\n">)}
    )
    (C {(test_expect_success)} 
      {(SQ <"git mv moves a submodule with a .git directory and no .gitmodules">)} 
      {
        (SQ <"\n"> <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> 
          <"\tgit rm .gitmodules &&\n"> <"\t(\n"> <"\t\tcd sub &&\n"> <"\t\trm -f .git &&\n"> <"\t\tcp -R -P -p ../.git/modules/sub .git &&\n"> 
          <"\t\tGIT_WORK_TREE=. git config --unset core.worktree\n"> <"\t) &&\n"> <"\tmkdir mod &&\n"> <"\tgit mv sub mod/sub &&\n"> <"\t! test -e sub &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> <"\t(\n"> <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git mv moves a submodule with a .git directory and .gitmodules">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> <"\t(\n"> <"\t\tcd sub &&\n"> <"\t\trm -f .git &&\n"> <"\t\tcp -R -P -p ../.git/modules/sub .git &&\n"> 
          <"\t\tGIT_WORK_TREE=. git config --unset core.worktree\n"> <"\t) &&\n"> <"\tmkdir mod &&\n"> <"\tgit mv sub mod/sub &&\n"> <"\t! test -e sub &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> <"\t(\n"> <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\techo mod/sub >expected &&\n"> 
          <"\tgit config -f .gitmodules submodule.sub.path >actual &&\n"> <"\ttest_cmp expected actual &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"git mv moves a submodule with gitfile">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> <"\tmkdir mod &&\n"> <"\t(\n"> <"\t\tcd mod &&\n"> <"\t\tgit mv ../sub/ .\n"> <"\t) &&\n"> 
          <"\t! test -e sub &&\n"> <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> <"\t(\n"> 
          <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\techo mod/sub >expected &&\n"> 
          <"\tgit config -f .gitmodules submodule.sub.path >actual &&\n"> <"\ttest_cmp expected actual &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"mv does not complain when no .gitmodules file is found">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tgit rm .gitmodules &&\n"> <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> <"\tmkdir mod &&\n"> 
          <"\tgit mv sub mod/sub 2>actual.err &&\n"> <"\t! test -s actual.err &&\n"> <"\t! test -e sub &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> <"\t(\n"> <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"mv will error out on a modified .gitmodules file unless staged">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tgit config -f .gitmodules foo.bar true &&\n"> <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> <"\tmkdir mod &&\n"> 
          <"\ttest_must_fail git mv sub mod/sub 2>actual.err &&\n"> <"\ttest -s actual.err &&\n"> <"\ttest -e sub &&\n"> <"\tgit diff-files --quiet -- sub &&\n"> 
          <"\tgit add .gitmodules &&\n"> <"\tgit mv sub mod/sub 2>actual.err &&\n"> <"\t! test -s actual.err &&\n"> <"\t! test -e sub &&\n"> 
          <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> <"\t(\n"> <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"mv issues a warning when section is not found in .gitmodules">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tgit config -f .gitmodules --remove-section submodule.sub &&\n"> <"\tgit add .gitmodules &&\n"> <"\tentry=\"$(git ls-files --stage sub | cut -f 1)\" &&\n"> 
          <
"\techo \"warning: Could not find section in .gitmodules where path=sub\" >expect.err &&\n"
          > <"\tmkdir mod &&\n"> <"\tgit mv sub mod/sub 2>actual.err &&\n"> 
          <"\ttest_i18ncmp expect.err actual.err &&\n"> <"\t! test -e sub &&\n"> <"\t[ \"$entry\" = \"$(git ls-files --stage mod/sub | cut -f 1)\" ] &&\n"> 
          <"\t(\n"> <"\t\tcd mod/sub &&\n"> <"\t\tgit status\n"> <"\t) &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"mv --dry-run does not touch the submodule or .gitmodules">)} 
      {
        (SQ <"\n"> <"\trm -rf mod &&\n"> <"\tgit reset --hard &&\n"> <"\tgit submodule update &&\n"> 
          <"\tmkdir mod &&\n"> <"\tgit mv -n sub mod/sub 2>actual.err &&\n"> <"\ttest -f sub/.git &&\n"> 
          <"\tgit diff-index --exit-code HEAD &&\n"> <"\tgit update-index --refresh &&\n"> <"\tgit diff-files --quiet -- sub .gitmodules\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"checking out a commit before submodule moved needs manual updates">)} 
      {
        (SQ <"\n"> <"\tgit mv sub sub2 &&\n"> <"\tgit commit -m \"moved sub to sub2\" &&\n"> 
          <"\tgit checkout -q HEAD^ 2>actual &&\n"> <"\ttest_i18ngrep \"^warning: unable to rmdir sub2:\" actual &&\n"> 
          <"\tgit status -s sub2 >actual &&\n"> <"\techo \"?? sub2/\" >expected &&\n"> <"\ttest_cmp expected actual &&\n"> 
          <"\t! test -f sub/.git &&\n"> <"\ttest -f sub2/.git &&\n"> <"\tgit submodule update &&\n"> <"\ttest -f sub/.git &&\n"> 
          <"\trm -rf sub2 &&\n"> <"\tgit diff-index --exit-code HEAD &&\n"> <"\tgit update-index --refresh &&\n"> 
          <"\tgit diff-files --quiet -- sub .gitmodules &&\n"> <"\tgit status -s sub2 >actual &&\n"> <"\t! test -s actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"mv -k does not accidentally destroy submodules">)} 
      {
        (SQ <"\n"> <"\tgit checkout submodule &&\n"> <"\tmkdir dummy dest &&\n"> 
          <"\tgit mv -k dummy sub dest &&\n"> <"\tgit status --porcelain >actual &&\n"> <"\tgrep \"^R  sub -> dest/sub\" actual &&\n"> 
          <"\tgit reset --hard &&\n"> <"\tgit checkout .\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"moving a submodule in nested directories">)} 
      {
        (SQ <"\n"> <"\t(\n"> <"\t\tcd deep &&\n"> <"\t\tgit mv directory ../ &&\n"> 
          <"\t\t# git status would fail if the update of linking git dir to\n"> <"\t\t# work dir of the submodule failed.\n"> <"\t\tgit status &&\n"> 
          <
"\t\tgit config -f ../.gitmodules submodule.deep/directory/hierarchy/sub.path >../actual &&\n"
          > <"\t\techo \"directory/hierarchy/sub\" >../expect\n"> <"\t) &&\n"> <"\ttest_cmp actual expect\n">
        )
      }
    )
    (C {(test_done)})
  ]
)