[thirdparty/git.git] / t / t2025-worktree-add.sh

#!/bin/sh

test_description='test git worktree add'

. ./test-lib.sh

. "$TEST_DIRECTORY"/lib-rebase.sh

test_expect_success 'setup' '
	test_commit init
'

test_expect_success '"add" an existing worktree' '
	mkdir -p existing/subtree &&
	test_must_fail git worktree add --detach existing master
'

test_expect_success '"add" an existing empty worktree' '
	mkdir existing_empty &&
	git worktree add --detach existing_empty master
'

test_expect_success '"add" using shorthand - fails when no previous branch' '
	test_must_fail git worktree add existing_short -
'

test_expect_success '"add" using - shorthand' '
	git checkout -b newbranch &&
	echo hello >myworld &&
	git add myworld &&
	git commit -m myworld &&
	git checkout master &&
	git worktree add short-hand - &&
	echo refs/heads/newbranch >expect &&
	git -C short-hand rev-parse --symbolic-full-name HEAD >actual &&
	test_cmp expect actual
'

test_expect_success '"add" refuses to checkout locked branch' '
	test_must_fail git worktree add zere master &&
	! test -d zere &&
	! test -d .git/worktrees/zere
'

test_expect_success 'checking out paths not complaining about linked checkouts' '
	(
	cd existing_empty &&
	echo dirty >>init.t &&
	git checkout master -- init.t
	)
'

test_expect_success '"add" worktree' '
	git rev-parse HEAD >expect &&
	git worktree add --detach here master &&
	(
		cd here &&
		test_cmp ../init.t init.t &&
		test_must_fail git symbolic-ref HEAD &&
		git rev-parse HEAD >actual &&
		test_cmp ../expect actual &&
		git fsck
	)
'

test_expect_success '"add" worktree with lock' '
	git rev-parse HEAD >expect &&
	git worktree add --detach --lock here-with-lock master &&
	test -f .git/worktrees/here-with-lock/locked
'

test_expect_success '"add" worktree from a subdir' '
	(
		mkdir sub &&
		cd sub &&
		git worktree add --detach here master &&
		cd here &&
		test_cmp ../../init.t init.t
	)
'

test_expect_success '"add" from a linked checkout' '
	(
		cd here &&
		git worktree add --detach nested-here master &&
		cd nested-here &&
		git fsck
	)
'

test_expect_success '"add" worktree creating new branch' '
	git worktree add -b newmaster there master &&
	(
		cd there &&
		test_cmp ../init.t init.t &&
		git symbolic-ref HEAD >actual &&
		echo refs/heads/newmaster >expect &&
		test_cmp expect actual &&
		git fsck
	)
'

test_expect_success 'die the same branch is already checked out' '
	(
		cd here &&
		test_must_fail git checkout newmaster
	)
'

test_expect_success SYMLINKS 'die the same branch is already checked out (symlink)' '
	head=$(git -C there rev-parse --git-path HEAD) &&
	ref=$(git -C there symbolic-ref HEAD) &&
	rm "$head" &&
	ln -s "$ref" "$head" &&
	test_must_fail git -C here checkout newmaster
'

test_expect_success 'not die the same branch is already checked out' '
	(
		cd here &&
		git worktree add --force anothernewmaster newmaster
	)
'

test_expect_success 'not die on re-checking out current branch' '
	(
		cd there &&
		git checkout newmaster
	)
'

test_expect_success '"add" from a bare repo' '
	(
		git clone --bare . bare &&
		cd bare &&
		git worktree add -b bare-master ../there2 master
	)
'

test_expect_success 'checkout from a bare repo without "add"' '
	(
		cd bare &&
		test_must_fail git checkout master
	)
'

test_expect_success '"add" default branch of a bare repo' '
	(
		git clone --bare . bare2 &&
		cd bare2 &&
		git worktree add ../there3 master
	)
'

test_expect_success 'checkout with grafts' '
	test_when_finished rm .git/info/grafts &&
	test_commit abc &&
	SHA1=$(git rev-parse HEAD) &&
	test_commit def &&
	test_commit xyz &&
	echo "$(git rev-parse HEAD) $SHA1" >.git/info/grafts &&
	cat >expected <<-\EOF &&
	xyz
	abc
	EOF
	git log --format=%s -2 >actual &&
	test_cmp expected actual &&
	git worktree add --detach grafted master &&
	git --git-dir=grafted/.git log --format=%s -2 >actual &&
	test_cmp expected actual
'

test_expect_success '"add" from relative HEAD' '
	test_commit a &&
	test_commit b &&
	test_commit c &&
	git rev-parse HEAD~1 >expected &&
	git worktree add relhead HEAD~1 &&
	git -C relhead rev-parse HEAD >actual &&
	test_cmp expected actual
'

test_expect_success '"add -b" with <branch> omitted' '
	git worktree add -b burble flornk &&
	test_cmp_rev HEAD burble
'

test_expect_success '"add --detach" with <branch> omitted' '
	git worktree add --detach fishhook &&
	git rev-parse HEAD >expected &&
	git -C fishhook rev-parse HEAD >actual &&
	test_cmp expected actual &&
	test_must_fail git -C fishhook symbolic-ref HEAD
'

test_expect_success '"add" with <branch> omitted' '
	git worktree add wiffle/bat &&
	test_cmp_rev HEAD bat
'

test_expect_success '"add" checks out existing branch of dwimd name' '
	git branch dwim HEAD~1 &&
	git worktree add dwim &&
	test_cmp_rev HEAD~1 dwim &&
	(
		cd dwim &&
		test_cmp_rev HEAD dwim
	)
'

test_expect_success '"add <path>" dwim fails with checked out branch' '
	git checkout -b test-branch &&
	test_must_fail git worktree add test-branch &&
	test_path_is_missing test-branch
'

test_expect_success '"add --force" with existing dwimd name doesnt die' '
	git checkout test-branch &&
	git worktree add --force test-branch
'

test_expect_success '"add" no auto-vivify with --detach and <branch> omitted' '
	git worktree add --detach mish/mash &&
	test_must_fail git rev-parse mash -- &&
	test_must_fail git -C mish/mash symbolic-ref HEAD
'

test_expect_success '"add" -b/-B mutually exclusive' '
	test_must_fail git worktree add -b poodle -B poodle bamboo master
'

test_expect_success '"add" -b/--detach mutually exclusive' '
	test_must_fail git worktree add -b poodle --detach bamboo master
'

test_expect_success '"add" -B/--detach mutually exclusive' '
	test_must_fail git worktree add -B poodle --detach bamboo master
'

test_expect_success '"add -B" fails if the branch is checked out' '
	git rev-parse newmaster >before &&
	test_must_fail git worktree add -B newmaster bamboo master &&
	git rev-parse newmaster >after &&
	test_cmp before after
'

test_expect_success 'add -B' '
	git worktree add -B poodle bamboo2 master^ &&
	git -C bamboo2 symbolic-ref HEAD >actual &&
	echo refs/heads/poodle >expected &&
	test_cmp expected actual &&
	test_cmp_rev master^ poodle
'

test_expect_success 'local clone from linked checkout' '
	git clone --local here here-clone &&
	( cd here-clone && git fsck )
'

test_expect_success 'local clone --shared from linked checkout' '
	git -C bare worktree add --detach ../baretree &&
	git clone --local --shared baretree bare-clone &&
	grep /bare/ bare-clone/.git/objects/info/alternates
'

test_expect_success '"add" worktree with --no-checkout' '
	git worktree add --no-checkout -b swamp swamp &&
	! test -e swamp/init.t &&
	git -C swamp reset --hard &&
	test_cmp init.t swamp/init.t
'

test_expect_success '"add" worktree with --checkout' '
	git worktree add --checkout -b swmap2 swamp2 &&
	test_cmp init.t swamp2/init.t
'

test_expect_success 'put a worktree under rebase' '
	git worktree add under-rebase &&
	(
		cd under-rebase &&
		set_fake_editor &&
		FAKE_LINES="edit 1" git rebase -i HEAD^ &&
		git worktree list | grep "under-rebase.*detached HEAD"
	)
'

test_expect_success 'add a worktree, checking out a rebased branch' '
	test_must_fail git worktree add new-rebase under-rebase &&
	! test -d new-rebase
'

test_expect_success 'checking out a rebased branch from another worktree' '
	git worktree add new-place &&
	test_must_fail git -C new-place checkout under-rebase
'

test_expect_success 'not allow to delete a branch under rebase' '
	(
		cd under-rebase &&
		test_must_fail git branch -D under-rebase
	)
'

test_expect_success 'rename a branch under rebase not allowed' '
	test_must_fail git branch -M under-rebase rebase-with-new-name
'

test_expect_success 'check out from current worktree branch ok' '
	(
		cd under-rebase &&
		git checkout under-rebase &&
		git checkout - &&
		git rebase --abort
	)
'

test_expect_success 'checkout a branch under bisect' '
	git worktree add under-bisect &&
	(
		cd under-bisect &&
		git bisect start &&
		git bisect bad &&
		git bisect good HEAD~2 &&
		git worktree list | grep "under-bisect.*detached HEAD" &&
		test_must_fail git worktree add new-bisect under-bisect &&
		! test -d new-bisect
	)
'

test_expect_success 'rename a branch under bisect not allowed' '
	test_must_fail git branch -M under-bisect bisect-with-new-name
'
# Is branch "refs/heads/$1" set to pull from "$2/$3"?
test_branch_upstream () {
	printf "%s\n" "$2" "refs/heads/$3" >expect.upstream &&
	{
		git config "branch.$1.remote" &&
		git config "branch.$1.merge"
	} >actual.upstream &&
	test_cmp expect.upstream actual.upstream
}

test_expect_success '--track sets up tracking' '
	test_when_finished rm -rf track &&
	git worktree add --track -b track track master &&
	test_branch_upstream track . master
'

# setup remote repository $1 and repository $2 with $1 set up as
# remote.  The remote has two branches, master and foo.
setup_remote_repo () {
	git init $1 &&
	(
		cd $1 &&
		test_commit $1_master &&
		git checkout -b foo &&
		test_commit upstream_foo
	) &&
	git init $2 &&
	(
		cd $2 &&
		test_commit $2_master &&
		git remote add $1 ../$1 &&
		git config remote.$1.fetch \
			"refs/heads/*:refs/remotes/$1/*" &&
		git fetch --all
	)
}

test_expect_success '--no-track avoids setting up tracking' '
	test_when_finished rm -rf repo_upstream repo_local foo &&
	setup_remote_repo repo_upstream repo_local &&
	(
		cd repo_local &&
		git worktree add --no-track -b foo ../foo repo_upstream/foo
	) &&
	(
		cd foo &&
		test_must_fail git config "branch.foo.remote" &&
		test_must_fail git config "branch.foo.merge" &&
		test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
	)
'

test_expect_success '"add" <path> <non-existent-branch> fails' '
	test_must_fail git worktree add foo non-existent
'

test_expect_success '"add" <path> <branch> dwims' '
	test_when_finished rm -rf repo_upstream repo_dwim foo &&
	setup_remote_repo repo_upstream repo_dwim &&
	git init repo_dwim &&
	(
		cd repo_dwim &&
		git worktree add ../foo foo
	) &&
	(
		cd foo &&
		test_branch_upstream foo repo_upstream foo &&
		test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
	)
'

test_expect_success 'git worktree add does not match remote' '
	test_when_finished rm -rf repo_a repo_b foo &&
	setup_remote_repo repo_a repo_b &&
	(
		cd repo_b &&
		git worktree add ../foo
	) &&
	(
		cd foo &&
		test_must_fail git config "branch.foo.remote" &&
		test_must_fail git config "branch.foo.merge" &&
		! test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	)
'

test_expect_success 'git worktree add --guess-remote sets up tracking' '
	test_when_finished rm -rf repo_a repo_b foo &&
	setup_remote_repo repo_a repo_b &&
	(
		cd repo_b &&
		git worktree add --guess-remote ../foo
	) &&
	(
		cd foo &&
		test_branch_upstream foo repo_a foo &&
		test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	)
'

test_expect_success 'git worktree add with worktree.guessRemote sets up tracking' '
	test_when_finished rm -rf repo_a repo_b foo &&
	setup_remote_repo repo_a repo_b &&
	(
		cd repo_b &&
		git config worktree.guessRemote true &&
		git worktree add ../foo
	) &&
	(
		cd foo &&
		test_branch_upstream foo repo_a foo &&
		test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	)
'

test_expect_success 'git worktree --no-guess-remote option overrides config' '
	test_when_finished rm -rf repo_a repo_b foo &&
	setup_remote_repo repo_a repo_b &&
	(
		cd repo_b &&
		git config worktree.guessRemote true &&
		git worktree add --no-guess-remote ../foo
	) &&
	(
		cd foo &&
		test_must_fail git config "branch.foo.remote" &&
		test_must_fail git config "branch.foo.merge" &&
		! test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	)
'

post_checkout_hook () {
	gitdir=${1:-.git}
	test_when_finished "rm -f $gitdir/hooks/post-checkout" &&
	mkdir -p $gitdir/hooks &&
	write_script $gitdir/hooks/post-checkout <<-\EOF
	{
		echo $*
		git rev-parse --git-dir --show-toplevel
	} >hook.actual
	EOF
}

test_expect_success '"add" invokes post-checkout hook (branch)' '
	post_checkout_hook &&
	{
		echo $ZERO_OID $(git rev-parse HEAD) 1 &&
		echo $(pwd)/.git/worktrees/gumby &&
		echo $(pwd)/gumby
	} >hook.expect &&
	git worktree add gumby &&
	test_cmp hook.expect gumby/hook.actual
'

test_expect_success '"add" invokes post-checkout hook (detached)' '
	post_checkout_hook &&
	{
		echo $ZERO_OID $(git rev-parse HEAD) 1 &&
		echo $(pwd)/.git/worktrees/grumpy &&
		echo $(pwd)/grumpy
	} >hook.expect &&
	git worktree add --detach grumpy &&
	test_cmp hook.expect grumpy/hook.actual
'

test_expect_success '"add --no-checkout" suppresses post-checkout hook' '
	post_checkout_hook &&
	rm -f hook.actual &&
	git worktree add --no-checkout gloopy &&
	test_path_is_missing gloopy/hook.actual
'

test_expect_success '"add" in other worktree invokes post-checkout hook' '
	post_checkout_hook &&
	{
		echo $ZERO_OID $(git rev-parse HEAD) 1 &&
		echo $(pwd)/.git/worktrees/guppy &&
		echo $(pwd)/guppy
	} >hook.expect &&
	git -C gloopy worktree add --detach ../guppy &&
	test_cmp hook.expect guppy/hook.actual
'

test_expect_success '"add" in bare repo invokes post-checkout hook' '
	rm -rf bare &&
	git clone --bare . bare &&
	{
		echo $ZERO_OID $(git --git-dir=bare rev-parse HEAD) 1 &&
		echo $(pwd)/bare/worktrees/goozy &&
		echo $(pwd)/goozy
	} >hook.expect &&
	post_checkout_hook bare &&
	git -C bare worktree add --detach ../goozy &&
	test_cmp hook.expect goozy/hook.actual
'

test_done
Commit	Line	Data
529fef20 NTND	1	#!/bin/sh
529fef20 NTND	2
f194b1ef	3	test_description='test git worktree add'
529fef20 NTND	4
	5	. ./test-lib.sh
	6
8d9fdd70 NTND	7	. "$TEST_DIRECTORY"/lib-rebase.sh
8d9fdd70 NTND	8
529fef20 NTND	9	test_expect_success 'setup' '
	10	test_commit init
	11	'
	12
f194b1ef	13	test_expect_success '"add" an existing worktree' '
ee4fb843	14	mkdir -p existing/subtree &&
f194b1ef	15	test_must_fail git worktree add --detach existing master
529fef20 NTND	16	'
529fef20 NTND	17
f194b1ef	18	test_expect_success '"add" an existing empty worktree' '
ee4fb843	19	mkdir existing_empty &&
f194b1ef	20	git worktree add --detach existing_empty master
ee4fb843 MK	21	'
ee4fb843 MK	22
1a450e2f JDG	23	test_expect_success '"add" using shorthand - fails when no previous branch' '
	24	test_must_fail git worktree add existing_short -
	25	'
	26
	27	test_expect_success '"add" using - shorthand' '
	28	git checkout -b newbranch &&
	29	echo hello >myworld &&
	30	git add myworld &&
	31	git commit -m myworld &&
	32	git checkout master &&
	33	git worktree add short-hand - &&
	34	echo refs/heads/newbranch >expect &&
	35	git -C short-hand rev-parse --symbolic-full-name HEAD >actual &&
	36	test_cmp expect actual
	37	'
	38
f194b1ef ES	39	test_expect_success '"add" refuses to checkout locked branch' '
f194b1ef ES	40	test_must_fail git worktree add zere master &&
3b8925c7 NTND	41	! test -d zere &&
	42	! test -d .git/worktrees/zere
	43	'
	44
e1c1ab9d NTND	45	test_expect_success 'checking out paths not complaining about linked checkouts' '
	46	(
	47	cd existing_empty &&
	48	echo dirty >>init.t &&
	49	git checkout master -- init.t
	50	)
	51	'
	52
f194b1ef	53	test_expect_success '"add" worktree' '
5883034c	54	git rev-parse HEAD >expect &&
f194b1ef	55	git worktree add --detach here master &&
529fef20 NTND	56	(
	57	cd here &&
	58	test_cmp ../init.t init.t &&
5883034c NTND	59	test_must_fail git symbolic-ref HEAD &&
	60	git rev-parse HEAD >actual &&
	61	test_cmp ../expect actual &&
529fef20 NTND	62	git fsck
	63	)
	64	'
	65
507e6e9e NTND	66	test_expect_success '"add" worktree with lock' '
	67	git rev-parse HEAD >expect &&
	68	git worktree add --detach --lock here-with-lock master &&
	69	test -f .git/worktrees/here-with-lock/locked
	70	'
	71
f194b1ef	72	test_expect_success '"add" worktree from a subdir' '
529fef20 NTND	73	(
	74	mkdir sub &&
	75	cd sub &&
f194b1ef	76	git worktree add --detach here master &&
529fef20 NTND	77	cd here &&
	78	test_cmp ../../init.t init.t
	79	)
	80	'
	81
f194b1ef	82	test_expect_success '"add" from a linked checkout' '
529fef20 NTND	83	(
529fef20 NTND	84	cd here &&
f194b1ef	85	git worktree add --detach nested-here master &&
529fef20 NTND	86	cd nested-here &&
	87	git fsck
	88	)
	89	'
	90
f194b1ef ES	91	test_expect_success '"add" worktree creating new branch' '
f194b1ef ES	92	git worktree add -b newmaster there master &&
529fef20 NTND	93	(
	94	cd there &&
	95	test_cmp ../init.t init.t &&
	96	git symbolic-ref HEAD >actual &&
	97	echo refs/heads/newmaster >expect &&
	98	test_cmp expect actual &&
	99	git fsck
	100	)
	101	'
	102
5883034c NTND	103	test_expect_success 'die the same branch is already checked out' '
	104	(
	105	cd here &&
	106	test_must_fail git checkout newmaster
	107	)
	108	'
	109
746bbdc6 ES	110	test_expect_success SYMLINKS 'die the same branch is already checked out (symlink)' '
	111	head=$(git -C there rev-parse --git-path HEAD) &&
	112	ref=$(git -C there symbolic-ref HEAD) &&
	113	rm "$head" &&
	114	ln -s "$ref" "$head" &&
	115	test_must_fail git -C here checkout newmaster
	116	'
	117
1d0fa898 NTND	118	test_expect_success 'not die the same branch is already checked out' '
	119	(
	120	cd here &&
f194b1ef	121	git worktree add --force anothernewmaster newmaster
1d0fa898 NTND	122	)
	123	'
	124
5883034c NTND	125	test_expect_success 'not die on re-checking out current branch' '
	126	(
	127	cd there &&
	128	git checkout newmaster
	129	)
	130	'
	131
f194b1ef	132	test_expect_success '"add" from a bare repo' '
3473ad0c DK	133	(
	134	git clone --bare . bare &&
	135	cd bare &&
f194b1ef	136	git worktree add -b bare-master ../there2 master
3473ad0c DK	137	)
	138	'
	139
f194b1ef	140	test_expect_success 'checkout from a bare repo without "add"' '
3473ad0c DK	141	(
	142	cd bare &&
	143	test_must_fail git checkout master
	144	)
	145	'
	146
171c646f DK	147	test_expect_success '"add" default branch of a bare repo' '
	148	(
	149	git clone --bare . bare2 &&
	150	cd bare2 &&
	151	git worktree add ../there3 master
	152	)
	153	'
	154
ad35f615 NTND	155	test_expect_success 'checkout with grafts' '
	156	test_when_finished rm .git/info/grafts &&
	157	test_commit abc &&
697b90d7	158	SHA1=$(git rev-parse HEAD) &&
ad35f615 NTND	159	test_commit def &&
ad35f615 NTND	160	test_commit xyz &&
697b90d7	161	echo "$(git rev-parse HEAD) $SHA1" >.git/info/grafts &&
ad35f615 NTND	162	cat >expected <<-\EOF &&
	163	xyz
	164	abc
	165	EOF
	166	git log --format=%s -2 >actual &&
	167	test_cmp expected actual &&
f194b1ef	168	git worktree add --detach grafted master &&
ad35f615 NTND	169	git --git-dir=grafted/.git log --format=%s -2 >actual &&
	170	test_cmp expected actual
	171	'
	172
f194b1ef	173	test_expect_success '"add" from relative HEAD' '
c990a4c1 ES	174	test_commit a &&
	175	test_commit b &&
	176	test_commit c &&
	177	git rev-parse HEAD~1 >expected &&
f194b1ef	178	git worktree add relhead HEAD~1 &&
c990a4c1 ES	179	git -C relhead rev-parse HEAD >actual &&
	180	test_cmp expected actual
	181	'
	182
0f4af3b9 ES	183	test_expect_success '"add -b" with <branch> omitted' '
	184	git worktree add -b burble flornk &&
	185	test_cmp_rev HEAD burble
	186	'
	187
5c942570 ES	188	test_expect_success '"add --detach" with <branch> omitted' '
	189	git worktree add --detach fishhook &&
	190	git rev-parse HEAD >expected &&
	191	git -C fishhook rev-parse HEAD >actual &&
	192	test_cmp expected actual &&
	193	test_must_fail git -C fishhook symbolic-ref HEAD
	194	'
	195
1eb07d82 ES	196	test_expect_success '"add" with <branch> omitted' '
	197	git worktree add wiffle/bat &&
	198	test_cmp_rev HEAD bat
	199	'
	200
f60a7b76 TG	201	test_expect_success '"add" checks out existing branch of dwimd name' '
	202	git branch dwim HEAD~1 &&
	203	git worktree add dwim &&
	204	test_cmp_rev HEAD~1 dwim &&
	205	(
	206	cd dwim &&
	207	test_cmp_rev HEAD dwim
	208	)
	209	'
	210
	211	test_expect_success '"add <path>" dwim fails with checked out branch' '
	212	git checkout -b test-branch &&
	213	test_must_fail git worktree add test-branch &&
	214	test_path_is_missing test-branch
	215	'
	216
	217	test_expect_success '"add --force" with existing dwimd name doesnt die' '
	218	git checkout test-branch &&
	219	git worktree add --force test-branch
1eb07d82 ES	220	'
1eb07d82 ES	221
5c942570 ES	222	test_expect_success '"add" no auto-vivify with --detach and <branch> omitted' '
	223	git worktree add --detach mish/mash &&
	224	test_must_fail git rev-parse mash -- &&
	225	test_must_fail git -C mish/mash symbolic-ref HEAD
	226	'
	227
ab0b2c53 ES	228	test_expect_success '"add" -b/-B mutually exclusive' '
	229	test_must_fail git worktree add -b poodle -B poodle bamboo master
	230	'
	231
	232	test_expect_success '"add" -b/--detach mutually exclusive' '
	233	test_must_fail git worktree add -b poodle --detach bamboo master
	234	'
	235
	236	test_expect_success '"add" -B/--detach mutually exclusive' '
	237	test_must_fail git worktree add -B poodle --detach bamboo master
	238	'
	239
beb6f24b NTND	240	test_expect_success '"add -B" fails if the branch is checked out' '
	241	git rev-parse newmaster >before &&
	242	test_must_fail git worktree add -B newmaster bamboo master &&
	243	git rev-parse newmaster >after &&
	244	test_cmp before after
	245	'
	246
0ebf4a2a NTND	247	test_expect_success 'add -B' '
	248	git worktree add -B poodle bamboo2 master^ &&
	249	git -C bamboo2 symbolic-ref HEAD >actual &&
	250	echo refs/heads/poodle >expected &&
	251	test_cmp expected actual &&
	252	test_cmp_rev master^ poodle
	253	'
	254
744e4697 NTND	255	test_expect_success 'local clone from linked checkout' '
	256	git clone --local here here-clone &&
	257	( cd here-clone && git fsck )
	258	'
	259
b3b05971 ES	260	test_expect_success 'local clone --shared from linked checkout' '
	261	git -C bare worktree add --detach ../baretree &&
	262	git clone --local --shared baretree bare-clone &&
	263	grep /bare/ bare-clone/.git/objects/info/alternates
	264	'
	265
ef2a0ac9 RZ	266	test_expect_success '"add" worktree with --no-checkout' '
	267	git worktree add --no-checkout -b swamp swamp &&
	268	! test -e swamp/init.t &&
	269	git -C swamp reset --hard &&
	270	test_cmp init.t swamp/init.t
	271	'
	272
	273	test_expect_success '"add" worktree with --checkout' '
	274	git worktree add --checkout -b swmap2 swamp2 &&
	275	test_cmp init.t swamp2/init.t
	276	'
	277
8d9fdd70 NTND	278	test_expect_success 'put a worktree under rebase' '
	279	git worktree add under-rebase &&
	280	(
	281	cd under-rebase &&
	282	set_fake_editor &&
	283	FAKE_LINES="edit 1" git rebase -i HEAD^ &&
	284	git worktree list \| grep "under-rebase.*detached HEAD"
	285	)
	286	'
	287
	288	test_expect_success 'add a worktree, checking out a rebased branch' '
	289	test_must_fail git worktree add new-rebase under-rebase &&
	290	! test -d new-rebase
	291	'
	292
	293	test_expect_success 'checking out a rebased branch from another worktree' '
	294	git worktree add new-place &&
	295	test_must_fail git -C new-place checkout under-rebase
	296	'
	297
	298	test_expect_success 'not allow to delete a branch under rebase' '
	299	(
	300	cd under-rebase &&
	301	test_must_fail git branch -D under-rebase
	302	)
	303	'
	304
14ace5b7 NTND	305	test_expect_success 'rename a branch under rebase not allowed' '
	306	test_must_fail git branch -M under-rebase rebase-with-new-name
	307	'
	308
8d9fdd70 NTND	309	test_expect_success 'check out from current worktree branch ok' '
	310	(
	311	cd under-rebase &&
	312	git checkout under-rebase &&
	313	git checkout - &&
	314	git rebase --abort
	315	)
	316	'
	317
04a3dfb8 NTND	318	test_expect_success 'checkout a branch under bisect' '
	319	git worktree add under-bisect &&
	320	(
	321	cd under-bisect &&
	322	git bisect start &&
	323	git bisect bad &&
	324	git bisect good HEAD~2 &&
	325	git worktree list \| grep "under-bisect.*detached HEAD" &&
	326	test_must_fail git worktree add new-bisect under-bisect &&
	327	! test -d new-bisect
	328	)
	329	'
	330
14ace5b7 NTND	331	test_expect_success 'rename a branch under bisect not allowed' '
	332	test_must_fail git branch -M under-bisect bisect-with-new-name
	333	'
e284e892 TG	334	# Is branch "refs/heads/$1" set to pull from "$2/$3"?
	335	test_branch_upstream () {
	336	printf "%s\n" "$2" "refs/heads/$3" >expect.upstream &&
	337	{
	338	git config "branch.$1.remote" &&
	339	git config "branch.$1.merge"
	340	} >actual.upstream &&
	341	test_cmp expect.upstream actual.upstream
	342	}
	343
	344	test_expect_success '--track sets up tracking' '
	345	test_when_finished rm -rf track &&
	346	git worktree add --track -b track track master &&
	347	test_branch_upstream track . master
	348	'
	349
	350	# setup remote repository $1 and repository $2 with $1 set up as
	351	# remote. The remote has two branches, master and foo.
	352	setup_remote_repo () {
	353	git init $1 &&
	354	(
	355	cd $1 &&
	356	test_commit $1_master &&
	357	git checkout -b foo &&
	358	test_commit upstream_foo
	359	) &&
	360	git init $2 &&
	361	(
	362	cd $2 &&
	363	test_commit $2_master &&
	364	git remote add $1 ../$1 &&
	365	git config remote.$1.fetch \
	366	"refs/heads/:refs/remotes/$1/" &&
	367	git fetch --all
	368	)
	369	}
	370
	371	test_expect_success '--no-track avoids setting up tracking' '
	372	test_when_finished rm -rf repo_upstream repo_local foo &&
	373	setup_remote_repo repo_upstream repo_local &&
	374	(
	375	cd repo_local &&
	376	git worktree add --no-track -b foo ../foo repo_upstream/foo
	377	) &&
	378	(
	379	cd foo &&
	380	test_must_fail git config "branch.foo.remote" &&
	381	test_must_fail git config "branch.foo.merge" &&
	382	test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
	383	)
	384	'
14ace5b7	385
4e853331 TG	386	test_expect_success '"add" <path> <non-existent-branch> fails' '
	387	test_must_fail git worktree add foo non-existent
	388	'
	389
	390	test_expect_success '"add" <path> <branch> dwims' '
	391	test_when_finished rm -rf repo_upstream repo_dwim foo &&
	392	setup_remote_repo repo_upstream repo_dwim &&
	393	git init repo_dwim &&
	394	(
	395	cd repo_dwim &&
	396	git worktree add ../foo foo
	397	) &&
	398	(
	399	cd foo &&
	400	test_branch_upstream foo repo_upstream foo &&
	401	test_cmp_rev refs/remotes/repo_upstream/foo refs/heads/foo
	402	)
	403	'
	404
71d6682d TG	405	test_expect_success 'git worktree add does not match remote' '
	406	test_when_finished rm -rf repo_a repo_b foo &&
	407	setup_remote_repo repo_a repo_b &&
	408	(
	409	cd repo_b &&
	410	git worktree add ../foo
	411	) &&
	412	(
	413	cd foo &&
	414	test_must_fail git config "branch.foo.remote" &&
	415	test_must_fail git config "branch.foo.merge" &&
	416	! test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	417	)
	418	'
	419
	420	test_expect_success 'git worktree add --guess-remote sets up tracking' '
	421	test_when_finished rm -rf repo_a repo_b foo &&
	422	setup_remote_repo repo_a repo_b &&
	423	(
	424	cd repo_b &&
	425	git worktree add --guess-remote ../foo
	426	) &&
	427	(
	428	cd foo &&
	429	test_branch_upstream foo repo_a foo &&
	430	test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	431	)
	432	'
	433
e92445a7 TG	434	test_expect_success 'git worktree add with worktree.guessRemote sets up tracking' '
	435	test_when_finished rm -rf repo_a repo_b foo &&
	436	setup_remote_repo repo_a repo_b &&
	437	(
	438	cd repo_b &&
	439	git config worktree.guessRemote true &&
	440	git worktree add ../foo
	441	) &&
	442	(
	443	cd foo &&
	444	test_branch_upstream foo repo_a foo &&
	445	test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	446	)
	447	'
	448
	449	test_expect_success 'git worktree --no-guess-remote option overrides config' '
	450	test_when_finished rm -rf repo_a repo_b foo &&
	451	setup_remote_repo repo_a repo_b &&
	452	(
	453	cd repo_b &&
	454	git config worktree.guessRemote true &&
	455	git worktree add --no-guess-remote ../foo
	456	) &&
	457	(
	458	cd foo &&
	459	test_must_fail git config "branch.foo.remote" &&
	460	test_must_fail git config "branch.foo.merge" &&
	461	! test_cmp_rev refs/remotes/repo_a/foo refs/heads/foo
	462	)
	463	'
	464
ade546be	465	post_checkout_hook () {
a4bf1e3c ES	466	gitdir=${1:-.git}
	467	test_when_finished "rm -f $gitdir/hooks/post-checkout" &&
	468	mkdir -p $gitdir/hooks &&
	469	write_script $gitdir/hooks/post-checkout <<-\EOF
	470	{
	471	echo $*
	472	git rev-parse --git-dir --show-toplevel
	473	} >hook.actual
ade546be ES	474	EOF
	475	}
	476
	477	test_expect_success '"add" invokes post-checkout hook (branch)' '
	478	post_checkout_hook &&
a4bf1e3c	479	{
8125a58b	480	echo $ZERO_OID $(git rev-parse HEAD) 1 &&
a4bf1e3c ES	481	echo $(pwd)/.git/worktrees/gumby &&
	482	echo $(pwd)/gumby
	483	} >hook.expect &&
ade546be	484	git worktree add gumby &&
a4bf1e3c	485	test_cmp hook.expect gumby/hook.actual
ade546be ES	486	'
	487
	488	test_expect_success '"add" invokes post-checkout hook (detached)' '
	489	post_checkout_hook &&
a4bf1e3c	490	{
8125a58b	491	echo $ZERO_OID $(git rev-parse HEAD) 1 &&
a4bf1e3c ES	492	echo $(pwd)/.git/worktrees/grumpy &&
	493	echo $(pwd)/grumpy
	494	} >hook.expect &&
ade546be	495	git worktree add --detach grumpy &&
a4bf1e3c	496	test_cmp hook.expect grumpy/hook.actual
ade546be ES	497	'
	498
	499	test_expect_success '"add --no-checkout" suppresses post-checkout hook' '
	500	post_checkout_hook &&
	501	rm -f hook.actual &&
	502	git worktree add --no-checkout gloopy &&
a4bf1e3c ES	503	test_path_is_missing gloopy/hook.actual
	504	'
	505
	506	test_expect_success '"add" in other worktree invokes post-checkout hook' '
	507	post_checkout_hook &&
	508	{
8125a58b	509	echo $ZERO_OID $(git rev-parse HEAD) 1 &&
a4bf1e3c ES	510	echo $(pwd)/.git/worktrees/guppy &&
	511	echo $(pwd)/guppy
	512	} >hook.expect &&
	513	git -C gloopy worktree add --detach ../guppy &&
	514	test_cmp hook.expect guppy/hook.actual
	515	'
	516
	517	test_expect_success '"add" in bare repo invokes post-checkout hook' '
	518	rm -rf bare &&
	519	git clone --bare . bare &&
	520	{
8125a58b	521	echo $ZERO_OID $(git --git-dir=bare rev-parse HEAD) 1 &&
a4bf1e3c ES	522	echo $(pwd)/bare/worktrees/goozy &&
	523	echo $(pwd)/goozy
	524	} >hook.expect &&
	525	post_checkout_hook bare &&
	526	git -C bare worktree add --detach ../goozy &&
	527	test_cmp hook.expect goozy/hook.actual
ade546be ES	528	'
ade546be ES	529
529fef20	530	test_done