[thirdparty/git.git] / t / t1404-update-ref-errors.sh

#!/bin/sh

test_description='Test git update-ref error handling'
. ./test-lib.sh

# Create some references, perhaps run pack-refs --all, then try to
# create some more references. Ensure that the second creation fails
# with the correct error message.
# Usage: test_update_rejected <before> <pack> <create> <error>
#   <before> is a ws-separated list of refs to create before the test
#   <pack> (true or false) tells whether to pack the refs before the test
#   <create> is a list of variables to attempt creating
#   <error> is a string to look for in the stderr of update-ref.
# All references are created in the namespace specified by the current
# value of $prefix.
test_update_rejected () {
	before="$1" &&
	pack="$2" &&
	create="$3" &&
	error="$4" &&
	printf "create $prefix/%s $C\n" $before |
	git update-ref --stdin &&
	git for-each-ref $prefix >unchanged &&
	if $pack
	then
		git pack-refs --all
	fi &&
	printf "create $prefix/%s $C\n" $create >input &&
	test_must_fail git update-ref --stdin <input 2>output.err &&
	grep -F "$error" output.err &&
	git for-each-ref $prefix >actual &&
	test_cmp unchanged actual
}

Q="'"

test_expect_success 'setup' '

	git commit --allow-empty -m Initial &&
	C=$(git rev-parse HEAD) &&
	git commit --allow-empty -m Second &&
	D=$(git rev-parse HEAD) &&
	git commit --allow-empty -m Third &&
	E=$(git rev-parse HEAD)
'

test_expect_success 'existing loose ref is a simple prefix of new' '

	prefix=refs/1l &&
	test_update_rejected "a c e" false "b c/x d" \
		"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x$Q"

'

test_expect_success 'existing packed ref is a simple prefix of new' '

	prefix=refs/1p &&
	test_update_rejected "a c e" true "b c/x d" \
		"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x$Q"

'

test_expect_success 'existing loose ref is a deeper prefix of new' '

	prefix=refs/2l &&
	test_update_rejected "a c e" false "b c/x/y d" \
		"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x/y$Q"

'

test_expect_success 'existing packed ref is a deeper prefix of new' '

	prefix=refs/2p &&
	test_update_rejected "a c e" true "b c/x/y d" \
		"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x/y$Q"

'

test_expect_success 'new ref is a simple prefix of existing loose' '

	prefix=refs/3l &&
	test_update_rejected "a c/x e" false "b c d" \
		"$Q$prefix/c/x$Q exists; cannot create $Q$prefix/c$Q"

'

test_expect_success 'new ref is a simple prefix of existing packed' '

	prefix=refs/3p &&
	test_update_rejected "a c/x e" true "b c d" \
		"$Q$prefix/c/x$Q exists; cannot create $Q$prefix/c$Q"

'

test_expect_success 'new ref is a deeper prefix of existing loose' '

	prefix=refs/4l &&
	test_update_rejected "a c/x/y e" false "b c d" \
		"$Q$prefix/c/x/y$Q exists; cannot create $Q$prefix/c$Q"

'

test_expect_success 'new ref is a deeper prefix of existing packed' '

	prefix=refs/4p &&
	test_update_rejected "a c/x/y e" true "b c d" \
		"$Q$prefix/c/x/y$Q exists; cannot create $Q$prefix/c$Q"

'

test_expect_success 'one new ref is a simple prefix of another' '

	prefix=refs/5 &&
	test_update_rejected "a e" false "b c c/x d" \
		"cannot process $Q$prefix/c$Q and $Q$prefix/c/x$Q at the same time"

'

test_expect_success 'empty directory should not fool rev-parse' '
	prefix=refs/e-rev-parse &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	echo "$C" >expected &&
	git rev-parse $prefix/foo >actual &&
	test_cmp expected actual
'

test_expect_success 'empty directory should not fool for-each-ref' '
	prefix=refs/e-for-each-ref &&
	git update-ref $prefix/foo $C &&
	git for-each-ref $prefix >expected &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	git for-each-ref $prefix >actual &&
	test_cmp expected actual
'

test_expect_success 'empty directory should not fool create' '
	prefix=refs/e-create &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "create %s $C\n" $prefix/foo |
	git update-ref --stdin
'

test_expect_success 'empty directory should not fool verify' '
	prefix=refs/e-verify &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "verify %s $C\n" $prefix/foo |
	git update-ref --stdin
'

test_expect_success 'empty directory should not fool 1-arg update' '
	prefix=refs/e-update-1 &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "update %s $D\n" $prefix/foo |
	git update-ref --stdin
'

test_expect_success 'empty directory should not fool 2-arg update' '
	prefix=refs/e-update-2 &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "update %s $D $C\n" $prefix/foo |
	git update-ref --stdin
'

test_expect_success 'empty directory should not fool 0-arg delete' '
	prefix=refs/e-delete-0 &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "delete %s\n" $prefix/foo |
	git update-ref --stdin
'

test_expect_success 'empty directory should not fool 1-arg delete' '
	prefix=refs/e-delete-1 &&
	git update-ref $prefix/foo $C &&
	git pack-refs --all &&
	mkdir -p .git/$prefix/foo/bar/baz &&
	printf "delete %s $C\n" $prefix/foo |
	git update-ref --stdin
'

# Test various errors when reading the old values of references...

test_expect_success 'missing old value blocks update' '
	prefix=refs/missing-update &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/foo $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks update' '
	prefix=refs/incorrect-update &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: is at $C but expected $D
	EOF
	printf "%s\n" "update $prefix/foo $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'existing old value blocks create' '
	prefix=refs/existing-create &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: reference already exists
	EOF
	printf "%s\n" "create $prefix/foo $E" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks delete' '
	prefix=refs/incorrect-delete &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: is at $C but expected $D
	EOF
	printf "%s\n" "delete $prefix/foo $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'missing old value blocks indirect update' '
	prefix=refs/missing-indirect-update &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/symref $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks indirect update' '
	prefix=refs/incorrect-indirect-update &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
	EOF
	printf "%s\n" "update $prefix/symref $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'existing old value blocks indirect create' '
	prefix=refs/existing-indirect-create &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: reference already exists
	EOF
	printf "%s\n" "create $prefix/symref $E" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks indirect delete' '
	prefix=refs/incorrect-indirect-delete &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
	EOF
	printf "%s\n" "delete $prefix/symref $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'missing old value blocks indirect no-deref update' '
	prefix=refs/missing-noderef-update &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: can${Q}t resolve old value
	EOF
	printf "%s\n" "option no-deref" "update $prefix/symref $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks indirect no-deref update' '
	prefix=refs/incorrect-noderef-update &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
	EOF
	printf "%s\n" "option no-deref" "update $prefix/symref $E $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_failure 'existing old value blocks indirect no-deref create' '
	prefix=refs/existing-noderef-create &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: reference already exists
	EOF
	printf "%s\n" "option no-deref" "create $prefix/symref $E" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'incorrect old value blocks indirect no-deref delete' '
	prefix=refs/incorrect-noderef-delete &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	git update-ref $prefix/foo $C &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
	EOF
	printf "%s\n" "option no-deref" "delete $prefix/symref $D" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'non-empty directory blocks create' '
	prefix=refs/ne-create &&
	mkdir -p .git/$prefix/foo/bar &&
	: >.git/$prefix/foo/bar/baz.lock &&
	test_when_finished "rm -f .git/$prefix/foo/bar/baz.lock" &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: there is a non-empty directory $Q.git/$prefix/foo$Q blocking reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/foo $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/foo $D $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'broken reference blocks create' '
	prefix=refs/broken-create &&
	mkdir -p .git/$prefix &&
	echo "gobbledigook" >.git/$prefix/foo &&
	test_when_finished "rm -f .git/$prefix/foo" &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
	EOF
	printf "%s\n" "update $prefix/foo $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
	EOF
	printf "%s\n" "update $prefix/foo $D $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'non-empty directory blocks indirect create' '
	prefix=refs/ne-indirect-create &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	mkdir -p .git/$prefix/foo/bar &&
	: >.git/$prefix/foo/bar/baz.lock &&
	test_when_finished "rm -f .git/$prefix/foo/bar/baz.lock" &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: there is a non-empty directory $Q.git/$prefix/foo$Q blocking reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/symref $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	EOF
	printf "%s\n" "update $prefix/symref $D $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_expect_success 'broken reference blocks indirect create' '
	prefix=refs/broken-indirect-create &&
	git symbolic-ref $prefix/symref $prefix/foo &&
	echo "gobbledigook" >.git/$prefix/foo &&
	test_when_finished "rm -f .git/$prefix/foo" &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
	EOF
	printf "%s\n" "update $prefix/symref $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err &&
	cat >expected <<-EOF &&
	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
	EOF
	printf "%s\n" "update $prefix/symref $D $C" |
	test_must_fail git update-ref --stdin 2>output.err &&
	test_cmp expected output.err
'

test_done
Commit	Line	Data
433efcad MH	1	#!/bin/sh
433efcad MH	2
bf0c6603	3	test_description='Test git update-ref error handling'
433efcad MH	4	. ./test-lib.sh
433efcad MH	5
017f7221 MH	6	# Create some references, perhaps run pack-refs --all, then try to
	7	# create some more references. Ensure that the second creation fails
	8	# with the correct error message.
	9	# Usage: test_update_rejected <before> <pack> <create> <error>
	10	# <before> is a ws-separated list of refs to create before the test
	11	# <pack> (true or false) tells whether to pack the refs before the test
	12	# <create> is a list of variables to attempt creating
	13	# <error> is a string to look for in the stderr of update-ref.
	14	# All references are created in the namespace specified by the current
	15	# value of $prefix.
433efcad	16	test_update_rejected () {
0e4b63b5 MH	17	before="$1" &&
	18	pack="$2" &&
	19	create="$3" &&
	20	error="$4" &&
433efcad MH	21	printf "create $prefix/%s $C\n" $before \|
	22	git update-ref --stdin &&
	23	git for-each-ref $prefix >unchanged &&
	24	if $pack
	25	then
	26	git pack-refs --all
	27	fi &&
	28	printf "create $prefix/%s $C\n" $create >input &&
	29	test_must_fail git update-ref --stdin <input 2>output.err &&
	30	grep -F "$error" output.err &&
	31	git for-each-ref $prefix >actual &&
	32	test_cmp unchanged actual
	33	}
	34
	35	Q="'"
	36
	37	test_expect_success 'setup' '
	38
	39	git commit --allow-empty -m Initial &&
19dd7d06 MH	40	C=$(git rev-parse HEAD) &&
19dd7d06 MH	41	git commit --allow-empty -m Second &&
c5119dcf MH	42	D=$(git rev-parse HEAD) &&
	43	git commit --allow-empty -m Third &&
	44	E=$(git rev-parse HEAD)
433efcad MH	45	'
	46
	47	test_expect_success 'existing loose ref is a simple prefix of new' '
	48
	49	prefix=refs/1l &&
0e4b63b5	50	test_update_rejected "a c e" false "b c/x d" \
5b2d8d6f	51	"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x$Q"
433efcad MH	52
	53	'
	54
	55	test_expect_success 'existing packed ref is a simple prefix of new' '
	56
	57	prefix=refs/1p &&
0e4b63b5	58	test_update_rejected "a c e" true "b c/x d" \
433efcad MH	59	"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x$Q"
	60
	61	'
	62
	63	test_expect_success 'existing loose ref is a deeper prefix of new' '
	64
	65	prefix=refs/2l &&
0e4b63b5	66	test_update_rejected "a c e" false "b c/x/y d" \
5b2d8d6f	67	"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x/y$Q"
433efcad MH	68
	69	'
	70
	71	test_expect_success 'existing packed ref is a deeper prefix of new' '
	72
	73	prefix=refs/2p &&
0e4b63b5	74	test_update_rejected "a c e" true "b c/x/y d" \
433efcad MH	75	"$Q$prefix/c$Q exists; cannot create $Q$prefix/c/x/y$Q"
	76
	77	'
	78
	79	test_expect_success 'new ref is a simple prefix of existing loose' '
	80
	81	prefix=refs/3l &&
0e4b63b5	82	test_update_rejected "a c/x e" false "b c d" \
5b2d8d6f	83	"$Q$prefix/c/x$Q exists; cannot create $Q$prefix/c$Q"
433efcad MH	84
	85	'
	86
	87	test_expect_success 'new ref is a simple prefix of existing packed' '
	88
	89	prefix=refs/3p &&
0e4b63b5	90	test_update_rejected "a c/x e" true "b c d" \
433efcad MH	91	"$Q$prefix/c/x$Q exists; cannot create $Q$prefix/c$Q"
	92
	93	'
	94
	95	test_expect_success 'new ref is a deeper prefix of existing loose' '
	96
	97	prefix=refs/4l &&
0e4b63b5	98	test_update_rejected "a c/x/y e" false "b c d" \
5b2d8d6f	99	"$Q$prefix/c/x/y$Q exists; cannot create $Q$prefix/c$Q"
433efcad MH	100
	101	'
	102
	103	test_expect_success 'new ref is a deeper prefix of existing packed' '
	104
	105	prefix=refs/4p &&
0e4b63b5	106	test_update_rejected "a c/x/y e" true "b c d" \
433efcad MH	107	"$Q$prefix/c/x/y$Q exists; cannot create $Q$prefix/c$Q"
	108
	109	'
	110
e911104c	111	test_expect_success 'one new ref is a simple prefix of another' '
433efcad MH	112
433efcad MH	113	prefix=refs/5 &&
0e4b63b5	114	test_update_rejected "a e" false "b c c/x d" \
433efcad MH	115	"cannot process $Q$prefix/c$Q and $Q$prefix/c/x$Q at the same time"
	116
	117	'
	118
e167a567	119	test_expect_success 'empty directory should not fool rev-parse' '
19dd7d06 MH	120	prefix=refs/e-rev-parse &&
	121	git update-ref $prefix/foo $C &&
	122	git pack-refs --all &&
	123	mkdir -p .git/$prefix/foo/bar/baz &&
	124	echo "$C" >expected &&
	125	git rev-parse $prefix/foo >actual &&
	126	test_cmp expected actual
	127	'
	128
	129	test_expect_success 'empty directory should not fool for-each-ref' '
	130	prefix=refs/e-for-each-ref &&
	131	git update-ref $prefix/foo $C &&
	132	git for-each-ref $prefix >expected &&
	133	git pack-refs --all &&
	134	mkdir -p .git/$prefix/foo/bar/baz &&
	135	git for-each-ref $prefix >actual &&
	136	test_cmp expected actual
	137	'
	138
	139	test_expect_success 'empty directory should not fool create' '
	140	prefix=refs/e-create &&
	141	mkdir -p .git/$prefix/foo/bar/baz &&
	142	printf "create %s $C\n" $prefix/foo \|
	143	git update-ref --stdin
	144	'
	145
	146	test_expect_success 'empty directory should not fool verify' '
	147	prefix=refs/e-verify &&
	148	git update-ref $prefix/foo $C &&
	149	git pack-refs --all &&
	150	mkdir -p .git/$prefix/foo/bar/baz &&
	151	printf "verify %s $C\n" $prefix/foo \|
	152	git update-ref --stdin
	153	'
	154
	155	test_expect_success 'empty directory should not fool 1-arg update' '
	156	prefix=refs/e-update-1 &&
	157	git update-ref $prefix/foo $C &&
	158	git pack-refs --all &&
	159	mkdir -p .git/$prefix/foo/bar/baz &&
	160	printf "update %s $D\n" $prefix/foo \|
	161	git update-ref --stdin
	162	'
	163
	164	test_expect_success 'empty directory should not fool 2-arg update' '
	165	prefix=refs/e-update-2 &&
	166	git update-ref $prefix/foo $C &&
	167	git pack-refs --all &&
	168	mkdir -p .git/$prefix/foo/bar/baz &&
	169	printf "update %s $D $C\n" $prefix/foo \|
	170	git update-ref --stdin
	171	'
	172
	173	test_expect_success 'empty directory should not fool 0-arg delete' '
	174	prefix=refs/e-delete-0 &&
	175	git update-ref $prefix/foo $C &&
	176	git pack-refs --all &&
	177	mkdir -p .git/$prefix/foo/bar/baz &&
	178	printf "delete %s\n" $prefix/foo \|
	179	git update-ref --stdin
	180	'
	181
	182	test_expect_success 'empty directory should not fool 1-arg delete' '
	183	prefix=refs/e-delete-1 &&
184	git update-ref $prefix/foo $C &&
185	git pack-refs --all &&
186	mkdir -p .git/$prefix/foo/bar/baz &&
187	printf "delete %s $C\n" $prefix/foo \|
188	git update-ref --stdin
189	'
190
c5119dcf MH	191	# Test various errors when reading the old values of references...
	192
	193	test_expect_success 'missing old value blocks update' '
	194	prefix=refs/missing-update &&
	195	cat >expected <<-EOF &&
	196	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	197	EOF
	198	printf "%s\n" "update $prefix/foo $E $D" \|
	199	test_must_fail git update-ref --stdin 2>output.err &&
	200	test_cmp expected output.err
	201	'
	202
	203	test_expect_success 'incorrect old value blocks update' '
	204	prefix=refs/incorrect-update &&
	205	git update-ref $prefix/foo $C &&
	206	cat >expected <<-EOF &&
	207	fatal: cannot lock ref $Q$prefix/foo$Q: is at $C but expected $D
	208	EOF
	209	printf "%s\n" "update $prefix/foo $E $D" \|
	210	test_must_fail git update-ref --stdin 2>output.err &&
	211	test_cmp expected output.err
	212	'
	213
	214	test_expect_success 'existing old value blocks create' '
	215	prefix=refs/existing-create &&
	216	git update-ref $prefix/foo $C &&
	217	cat >expected <<-EOF &&
	218	fatal: cannot lock ref $Q$prefix/foo$Q: reference already exists
	219	EOF
	220	printf "%s\n" "create $prefix/foo $E" \|
	221	test_must_fail git update-ref --stdin 2>output.err &&
	222	test_cmp expected output.err
	223	'
	224
	225	test_expect_success 'incorrect old value blocks delete' '
	226	prefix=refs/incorrect-delete &&
	227	git update-ref $prefix/foo $C &&
	228	cat >expected <<-EOF &&
	229	fatal: cannot lock ref $Q$prefix/foo$Q: is at $C but expected $D
	230	EOF
	231	printf "%s\n" "delete $prefix/foo $D" \|
	232	test_must_fail git update-ref --stdin 2>output.err &&
	233	test_cmp expected output.err
	234	'
	235
	236	test_expect_success 'missing old value blocks indirect update' '
	237	prefix=refs/missing-indirect-update &&
	238	git symbolic-ref $prefix/symref $prefix/foo &&
	239	cat >expected <<-EOF &&
	240	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
	241	EOF
	242	printf "%s\n" "update $prefix/symref $E $D" \|
	243	test_must_fail git update-ref --stdin 2>output.err &&
	244	test_cmp expected output.err
	245	'
	246
	247	test_expect_success 'incorrect old value blocks indirect update' '
	248	prefix=refs/incorrect-indirect-update &&
	249	git symbolic-ref $prefix/symref $prefix/foo &&
	250	git update-ref $prefix/foo $C &&
	251	cat >expected <<-EOF &&
	252	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
	253	EOF
	254	printf "%s\n" "update $prefix/symref $E $D" \|
255	test_must_fail git update-ref --stdin 2>output.err &&
256	test_cmp expected output.err
257	'
258
259	test_expect_success 'existing old value blocks indirect create' '
260	prefix=refs/existing-indirect-create &&
261	git symbolic-ref $prefix/symref $prefix/foo &&
262	git update-ref $prefix/foo $C &&
263	cat >expected <<-EOF &&
264	fatal: cannot lock ref $Q$prefix/symref$Q: reference already exists
265	EOF
266	printf "%s\n" "create $prefix/symref $E" \|
267	test_must_fail git update-ref --stdin 2>output.err &&
268	test_cmp expected output.err
269	'
270
271	test_expect_success 'incorrect old value blocks indirect delete' '
272	prefix=refs/incorrect-indirect-delete &&
273	git symbolic-ref $prefix/symref $prefix/foo &&
274	git update-ref $prefix/foo $C &&
275	cat >expected <<-EOF &&
276	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
277	EOF
278	printf "%s\n" "delete $prefix/symref $D" \|
279	test_must_fail git update-ref --stdin 2>output.err &&
280	test_cmp expected output.err
281	'
282
283	test_expect_success 'missing old value blocks indirect no-deref update' '
284	prefix=refs/missing-noderef-update &&
285	git symbolic-ref $prefix/symref $prefix/foo &&
286	cat >expected <<-EOF &&
287	fatal: cannot lock ref $Q$prefix/symref$Q: can${Q}t resolve old value
288	EOF
289	printf "%s\n" "option no-deref" "update $prefix/symref $E $D" \|
290	test_must_fail git update-ref --stdin 2>output.err &&
291	test_cmp expected output.err
292	'
293
294	test_expect_success 'incorrect old value blocks indirect no-deref update' '
295	prefix=refs/incorrect-noderef-update &&
296	git symbolic-ref $prefix/symref $prefix/foo &&
297	git update-ref $prefix/foo $C &&
298	cat >expected <<-EOF &&
299	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
300	EOF
301	printf "%s\n" "option no-deref" "update $prefix/symref $E $D" \|
302	test_must_fail git update-ref --stdin 2>output.err &&
303	test_cmp expected output.err
304	'
305
306	test_expect_failure 'existing old value blocks indirect no-deref create' '
307	prefix=refs/existing-noderef-create &&
308	git symbolic-ref $prefix/symref $prefix/foo &&
309	git update-ref $prefix/foo $C &&
310	cat >expected <<-EOF &&
311	fatal: cannot lock ref $Q$prefix/symref$Q: reference already exists
312	EOF
313	printf "%s\n" "option no-deref" "create $prefix/symref $E" \|
314	test_must_fail git update-ref --stdin 2>output.err &&
315	test_cmp expected output.err
316	'
317
318	test_expect_success 'incorrect old value blocks indirect no-deref delete' '
319	prefix=refs/incorrect-noderef-delete &&
320	git symbolic-ref $prefix/symref $prefix/foo &&
321	git update-ref $prefix/foo $C &&
322	cat >expected <<-EOF &&
323	fatal: cannot lock ref $Q$prefix/symref$Q: is at $C but expected $D
324	EOF
325	printf "%s\n" "option no-deref" "delete $prefix/symref $D" \|
326	test_must_fail git update-ref --stdin 2>output.err &&
327	test_cmp expected output.err
328	'
329
330	test_expect_success 'non-empty directory blocks create' '
331	prefix=refs/ne-create &&
332	mkdir -p .git/$prefix/foo/bar &&
333	: >.git/$prefix/foo/bar/baz.lock &&
334	test_when_finished "rm -f .git/$prefix/foo/bar/baz.lock" &&
335	cat >expected <<-EOF &&
336	fatal: cannot lock ref $Q$prefix/foo$Q: there is a non-empty directory $Q.git/$prefix/foo$Q blocking reference $Q$prefix/foo$Q
337	EOF
338	printf "%s\n" "update $prefix/foo $C" \|
339	test_must_fail git update-ref --stdin 2>output.err &&
340	test_cmp expected output.err &&
341	cat >expected <<-EOF &&
342	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
343	EOF
344	printf "%s\n" "update $prefix/foo $D $C" \|
345	test_must_fail git update-ref --stdin 2>output.err &&
346	test_cmp expected output.err
347	'
348
349	test_expect_success 'broken reference blocks create' '
350	prefix=refs/broken-create &&
351	mkdir -p .git/$prefix &&
352	echo "gobbledigook" >.git/$prefix/foo &&
353	test_when_finished "rm -f .git/$prefix/foo" &&
354	cat >expected <<-EOF &&
355	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
356	EOF
357	printf "%s\n" "update $prefix/foo $C" \|
358	test_must_fail git update-ref --stdin 2>output.err &&
359	test_cmp expected output.err &&
360	cat >expected <<-EOF &&
361	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
362	EOF
363	printf "%s\n" "update $prefix/foo $D $C" \|
364	test_must_fail git update-ref --stdin 2>output.err &&
365	test_cmp expected output.err
366	'
367
368	test_expect_success 'non-empty directory blocks indirect create' '
369	prefix=refs/ne-indirect-create &&
370	git symbolic-ref $prefix/symref $prefix/foo &&
371	mkdir -p .git/$prefix/foo/bar &&
372	: >.git/$prefix/foo/bar/baz.lock &&
373	test_when_finished "rm -f .git/$prefix/foo/bar/baz.lock" &&
374	cat >expected <<-EOF &&
375	fatal: cannot lock ref $Q$prefix/foo$Q: there is a non-empty directory $Q.git/$prefix/foo$Q blocking reference $Q$prefix/foo$Q
376	EOF
377	printf "%s\n" "update $prefix/symref $C" \|
378	test_must_fail git update-ref --stdin 2>output.err &&
379	test_cmp expected output.err &&
380	cat >expected <<-EOF &&
381	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q
382	EOF
383	printf "%s\n" "update $prefix/symref $D $C" \|
384	test_must_fail git update-ref --stdin 2>output.err &&
385	test_cmp expected output.err
386	'
387
388	test_expect_success 'broken reference blocks indirect create' '
389	prefix=refs/broken-indirect-create &&
390	git symbolic-ref $prefix/symref $prefix/foo &&
391	echo "gobbledigook" >.git/$prefix/foo &&
392	test_when_finished "rm -f .git/$prefix/foo" &&
393	cat >expected <<-EOF &&
394	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
395	EOF
396	printf "%s\n" "update $prefix/symref $C" \|
397	test_must_fail git update-ref --stdin 2>output.err &&
398	test_cmp expected output.err &&
399	cat >expected <<-EOF &&
400	fatal: cannot lock ref $Q$prefix/foo$Q: unable to resolve reference $Q$prefix/foo$Q: reference broken
401	EOF
402	printf "%s\n" "update $prefix/symref $D $C" \|
403	test_must_fail git update-ref --stdin 2>output.err &&
404	test_cmp expected output.err
405	'
406
433efcad	407	test_done