Merge branch 'jt/upload-pack-error-report' into maint
[git] / t / t1400-update-ref.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2006 Shawn Pearce
4 #
5
6 test_description='Test git update-ref and basic ref logging'
7 . ./test-lib.sh
8
9 Z=$_z40
10
11 m=refs/heads/master
12 n_dir=refs/heads/gu
13 n=$n_dir/fixes
14 outside=refs/foo
15 bare=bare-repo
16
17 create_test_commits ()
18 {
19         prfx="$1"
20         for name in A B C D E F
21         do
22                 test_tick &&
23                 T=$(git write-tree) &&
24                 sha1=$(echo $name | git commit-tree $T) &&
25                 eval $prfx$name=$sha1
26         done
27 }
28
29 test_expect_success setup '
30         create_test_commits "" &&
31         mkdir $bare &&
32         cd $bare &&
33         git init --bare &&
34         create_test_commits "bare" &&
35         cd -
36 '
37
38 test_expect_success \
39         "create $m" \
40         "git update-ref $m $A &&
41          test $A"' = $(cat .git/'"$m"')'
42 test_expect_success \
43         "create $m" \
44         "git update-ref $m $B $A &&
45          test $B"' = $(cat .git/'"$m"')'
46 test_expect_success "fail to delete $m with stale ref" '
47         test_must_fail git update-ref -d $m $A &&
48         test $B = "$(cat .git/$m)"
49 '
50 test_expect_success "delete $m" '
51         git update-ref -d $m $B &&
52         ! test -f .git/$m
53 '
54 rm -f .git/$m
55
56 test_expect_success "delete $m without oldvalue verification" "
57         git update-ref $m $A &&
58         test $A = \$(cat .git/$m) &&
59         git update-ref -d $m &&
60         ! test -f .git/$m
61 "
62 rm -f .git/$m
63
64 test_expect_success \
65         "fail to create $n" \
66         "touch .git/$n_dir &&
67          test_must_fail git update-ref $n $A >out 2>err"
68 rm -f .git/$n_dir out err
69
70 test_expect_success \
71         "create $m (by HEAD)" \
72         "git update-ref HEAD $A &&
73          test $A"' = $(cat .git/'"$m"')'
74 test_expect_success \
75         "create $m (by HEAD)" \
76         "git update-ref HEAD $B $A &&
77          test $B"' = $(cat .git/'"$m"')'
78 test_expect_success "fail to delete $m (by HEAD) with stale ref" '
79         test_must_fail git update-ref -d HEAD $A &&
80         test $B = $(cat .git/$m)
81 '
82 test_expect_success "delete $m (by HEAD)" '
83         git update-ref -d HEAD $B &&
84         ! test -f .git/$m
85 '
86 rm -f .git/$m
87
88 test_expect_success 'update-ref does not create reflogs by default' '
89         test_when_finished "git update-ref -d $outside" &&
90         git update-ref $outside $A &&
91         git rev-parse $A >expect &&
92         git rev-parse $outside >actual &&
93         test_cmp expect actual &&
94         test_must_fail git reflog exists $outside
95 '
96
97 test_expect_success 'update-ref creates reflogs with --create-reflog' '
98         test_when_finished "git update-ref -d $outside" &&
99         git update-ref --create-reflog $outside $A &&
100         git rev-parse $A >expect &&
101         git rev-parse $outside >actual &&
102         test_cmp expect actual &&
103         git reflog exists $outside
104 '
105
106 test_expect_success 'creates no reflog in bare repository' '
107         git -C $bare update-ref $m $bareA &&
108         git -C $bare rev-parse $bareA >expect &&
109         git -C $bare rev-parse $m >actual &&
110         test_cmp expect actual &&
111         test_must_fail git -C $bare reflog exists $m
112 '
113
114 test_expect_success 'core.logAllRefUpdates=true creates reflog in bare repository' '
115         test_when_finished "git -C $bare config --unset core.logAllRefUpdates && \
116                 rm $bare/logs/$m" &&
117         git -C $bare config core.logAllRefUpdates true &&
118         git -C $bare update-ref $m $bareB &&
119         git -C $bare rev-parse $bareB >expect &&
120         git -C $bare rev-parse $m >actual &&
121         test_cmp expect actual &&
122         git -C $bare reflog exists $m
123 '
124
125 test_expect_success 'core.logAllRefUpdates=true does not create reflog by default' '
126         test_config core.logAllRefUpdates true &&
127         test_when_finished "git update-ref -d $outside" &&
128         git update-ref $outside $A &&
129         git rev-parse $A >expect &&
130         git rev-parse $outside >actual &&
131         test_cmp expect actual &&
132         test_must_fail git reflog exists $outside
133 '
134
135 test_expect_success 'core.logAllRefUpdates=always creates reflog by default' '
136         test_config core.logAllRefUpdates always &&
137         test_when_finished "git update-ref -d $outside" &&
138         git update-ref $outside $A &&
139         git rev-parse $A >expect &&
140         git rev-parse $outside >actual &&
141         test_cmp expect actual &&
142         git reflog exists $outside
143 '
144
145 test_expect_success 'core.logAllRefUpdates=always creates no reflog for ORIG_HEAD' '
146         test_config core.logAllRefUpdates always &&
147         git update-ref ORIG_HEAD $A &&
148         test_must_fail git reflog exists ORIG_HEAD
149 '
150
151 test_expect_success '--no-create-reflog overrides core.logAllRefUpdates=always' '
152         test_config core.logAllRefUpdates true &&
153         test_when_finished "git update-ref -d $outside" &&
154         git update-ref --no-create-reflog $outside $A &&
155         git rev-parse $A >expect &&
156         git rev-parse $outside >actual &&
157         test_cmp expect actual &&
158         test_must_fail git reflog exists $outside
159 '
160
161 test_expect_success \
162         "create $m (by HEAD)" \
163         "git update-ref HEAD $A &&
164          test $A"' = $(cat .git/'"$m"')'
165 test_expect_success \
166         "pack refs" \
167         "git pack-refs --all"
168 test_expect_success \
169         "move $m (by HEAD)" \
170         "git update-ref HEAD $B $A &&
171          test $B"' = $(cat .git/'"$m"')'
172 test_expect_success "delete $m (by HEAD) should remove both packed and loose $m" '
173         git update-ref -d HEAD $B &&
174         ! grep "$m" .git/packed-refs &&
175         ! test -f .git/$m
176 '
177 rm -f .git/$m
178
179 cp -f .git/HEAD .git/HEAD.orig
180 test_expect_success "delete symref without dereference" '
181         git update-ref --no-deref -d HEAD &&
182         ! test -f .git/HEAD
183 '
184 cp -f .git/HEAD.orig .git/HEAD
185
186 test_expect_success "delete symref without dereference when the referred ref is packed" '
187         echo foo >foo.c &&
188         git add foo.c &&
189         git commit -m foo &&
190         git pack-refs --all &&
191         git update-ref --no-deref -d HEAD &&
192         ! test -f .git/HEAD
193 '
194 cp -f .git/HEAD.orig .git/HEAD
195 git update-ref -d $m
196
197 test_expect_success 'update-ref -d is not confused by self-reference' '
198         git symbolic-ref refs/heads/self refs/heads/self &&
199         test_when_finished "rm -f .git/refs/heads/self" &&
200         test_path_is_file .git/refs/heads/self &&
201         test_must_fail git update-ref -d refs/heads/self &&
202         test_path_is_file .git/refs/heads/self
203 '
204
205 test_expect_success 'update-ref --no-deref -d can delete self-reference' '
206         git symbolic-ref refs/heads/self refs/heads/self &&
207         test_when_finished "rm -f .git/refs/heads/self" &&
208         test_path_is_file .git/refs/heads/self &&
209         git update-ref --no-deref -d refs/heads/self &&
210         test_path_is_missing .git/refs/heads/self
211 '
212
213 test_expect_success 'update-ref --no-deref -d can delete reference to bad ref' '
214         >.git/refs/heads/bad &&
215         test_when_finished "rm -f .git/refs/heads/bad" &&
216         git symbolic-ref refs/heads/ref-to-bad refs/heads/bad &&
217         test_when_finished "rm -f .git/refs/heads/ref-to-bad" &&
218         test_path_is_file .git/refs/heads/ref-to-bad &&
219         git update-ref --no-deref -d refs/heads/ref-to-bad &&
220         test_path_is_missing .git/refs/heads/ref-to-bad
221 '
222
223 test_expect_success '(not) create HEAD with old sha1' "
224         test_must_fail git update-ref HEAD $A $B
225 "
226 test_expect_success "(not) prior created .git/$m" "
227         ! test -f .git/$m
228 "
229 rm -f .git/$m
230
231 test_expect_success \
232         "create HEAD" \
233         "git update-ref HEAD $A"
234 test_expect_success '(not) change HEAD with wrong SHA1' "
235         test_must_fail git update-ref HEAD $B $Z
236 "
237 test_expect_success "(not) changed .git/$m" "
238         ! test $B"' = $(cat .git/'"$m"')
239 '
240 rm -f .git/$m
241
242 rm -f .git/logs/refs/heads/master
243 test_expect_success \
244         "create $m (logged by touch)" \
245         'GIT_COMMITTER_DATE="2005-05-26 23:30" \
246          git update-ref --create-reflog HEAD '"$A"' -m "Initial Creation" &&
247          test '"$A"' = $(cat .git/'"$m"')'
248 test_expect_success \
249         "update $m (logged by touch)" \
250         'GIT_COMMITTER_DATE="2005-05-26 23:31" \
251          git update-ref HEAD'" $B $A "'-m "Switch" &&
252          test '"$B"' = $(cat .git/'"$m"')'
253 test_expect_success \
254         "set $m (logged by touch)" \
255         'GIT_COMMITTER_DATE="2005-05-26 23:41" \
256          git update-ref HEAD'" $A &&
257          test $A"' = $(cat .git/'"$m"')'
258
259 cat >expect <<EOF
260 $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000       Initial Creation
261 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150260 +0000       Switch
262 $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000
263 EOF
264 test_expect_success \
265         "verifying $m's log" \
266         "test_cmp expect .git/logs/$m"
267 rm -rf .git/$m .git/logs expect
268
269 test_expect_success \
270         'enable core.logAllRefUpdates' \
271         'git config core.logAllRefUpdates true &&
272          test true = $(git config --bool --get core.logAllRefUpdates)'
273
274 test_expect_success \
275         "create $m (logged by config)" \
276         'GIT_COMMITTER_DATE="2005-05-26 23:32" \
277          git update-ref HEAD'" $A "'-m "Initial Creation" &&
278          test '"$A"' = $(cat .git/'"$m"')'
279 test_expect_success \
280         "update $m (logged by config)" \
281         'GIT_COMMITTER_DATE="2005-05-26 23:33" \
282          git update-ref HEAD'" $B $A "'-m "Switch" &&
283          test '"$B"' = $(cat .git/'"$m"')'
284 test_expect_success \
285         "set $m (logged by config)" \
286         'GIT_COMMITTER_DATE="2005-05-26 23:43" \
287          git update-ref HEAD '"$A &&
288          test $A"' = $(cat .git/'"$m"')'
289
290 cat >expect <<EOF
291 $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 +0000       Initial Creation
292 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 +0000       Switch
293 $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 +0000
294 EOF
295 test_expect_success \
296         "verifying $m's log" \
297         'test_cmp expect .git/logs/$m'
298 rm -f .git/$m .git/logs/$m expect
299
300 git update-ref $m $D
301 cat >.git/logs/$m <<EOF
302 0000000000000000000000000000000000000000 $C $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 -0500
303 $C $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150350 -0500
304 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 -0500
305 $F $Z $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150680 -0500
306 $Z $E $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 -0500
307 EOF
308
309 ed="Thu, 26 May 2005 18:32:00 -0500"
310 gd="Thu, 26 May 2005 18:33:00 -0500"
311 ld="Thu, 26 May 2005 18:43:00 -0500"
312 test_expect_success \
313         'Query "master@{May 25 2005}" (before history)' \
314         'rm -f o e &&
315          git rev-parse --verify "master@{May 25 2005}" >o 2>e &&
316          test '"$C"' = $(cat o) &&
317          test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"'
318 test_expect_success \
319         "Query master@{2005-05-25} (before history)" \
320         'rm -f o e &&
321          git rev-parse --verify master@{2005-05-25} >o 2>e &&
322          test '"$C"' = $(cat o) &&
323          echo test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"'
324 test_expect_success \
325         'Query "master@{May 26 2005 23:31:59}" (1 second before history)' \
326         'rm -f o e &&
327          git rev-parse --verify "master@{May 26 2005 23:31:59}" >o 2>e &&
328          test '"$C"' = $(cat o) &&
329          test "warning: Log for '\''master'\'' only goes back to $ed." = "$(cat e)"'
330 test_expect_success \
331         'Query "master@{May 26 2005 23:32:00}" (exactly history start)' \
332         'rm -f o e &&
333          git rev-parse --verify "master@{May 26 2005 23:32:00}" >o 2>e &&
334          test '"$C"' = $(cat o) &&
335          test "" = "$(cat e)"'
336 test_expect_success \
337         'Query "master@{May 26 2005 23:32:30}" (first non-creation change)' \
338         'rm -f o e &&
339          git rev-parse --verify "master@{May 26 2005 23:32:30}" >o 2>e &&
340          test '"$A"' = $(cat o) &&
341          test "" = "$(cat e)"'
342 test_expect_success \
343         'Query "master@{2005-05-26 23:33:01}" (middle of history with gap)' \
344         'rm -f o e &&
345          git rev-parse --verify "master@{2005-05-26 23:33:01}" >o 2>e &&
346          test '"$B"' = $(cat o) &&
347          test "warning: Log for ref '"$m has gap after $gd"'." = "$(cat e)"'
348 test_expect_success \
349         'Query "master@{2005-05-26 23:38:00}" (middle of history)' \
350         'rm -f o e &&
351          git rev-parse --verify "master@{2005-05-26 23:38:00}" >o 2>e &&
352          test '"$Z"' = $(cat o) &&
353          test "" = "$(cat e)"'
354 test_expect_success \
355         'Query "master@{2005-05-26 23:43:00}" (exact end of history)' \
356         'rm -f o e &&
357          git rev-parse --verify "master@{2005-05-26 23:43:00}" >o 2>e &&
358          test '"$E"' = $(cat o) &&
359          test "" = "$(cat e)"'
360 test_expect_success \
361         'Query "master@{2005-05-28}" (past end of history)' \
362         'rm -f o e &&
363          git rev-parse --verify "master@{2005-05-28}" >o 2>e &&
364          test '"$D"' = $(cat o) &&
365          test "warning: Log for ref '"$m unexpectedly ended on $ld"'." = "$(cat e)"'
366
367
368 rm -f .git/$m .git/logs/$m expect
369
370 test_expect_success \
371     'creating initial files' \
372     'echo TEST >F &&
373      git add F &&
374          GIT_AUTHOR_DATE="2005-05-26 23:30" \
375          GIT_COMMITTER_DATE="2005-05-26 23:30" git commit -m add -a &&
376          h_TEST=$(git rev-parse --verify HEAD) &&
377          echo The other day this did not work. >M &&
378          echo And then Bob told me how to fix it. >>M &&
379          echo OTHER >F &&
380          GIT_AUTHOR_DATE="2005-05-26 23:41" \
381          GIT_COMMITTER_DATE="2005-05-26 23:41" git commit -F M -a &&
382          h_OTHER=$(git rev-parse --verify HEAD) &&
383          GIT_AUTHOR_DATE="2005-05-26 23:44" \
384          GIT_COMMITTER_DATE="2005-05-26 23:44" git commit --amend &&
385          h_FIXED=$(git rev-parse --verify HEAD) &&
386          echo Merged initial commit and a later commit. >M &&
387          echo $h_TEST >.git/MERGE_HEAD &&
388          GIT_AUTHOR_DATE="2005-05-26 23:45" \
389          GIT_COMMITTER_DATE="2005-05-26 23:45" git commit -F M &&
390          h_MERGED=$(git rev-parse --verify HEAD) &&
391          rm -f M'
392
393 cat >expect <<EOF
394 $Z $h_TEST $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000  commit (initial): add
395 $h_TEST $h_OTHER $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000    commit: The other day this did not work.
396 $h_OTHER $h_FIXED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151040 +0000   commit (amend): The other day this did not work.
397 $h_FIXED $h_MERGED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151100 +0000  commit (merge): Merged initial commit and a later commit.
398 EOF
399 test_expect_success \
400         'git commit logged updates' \
401         "test_cmp expect .git/logs/$m"
402 unset h_TEST h_OTHER h_FIXED h_MERGED
403
404 test_expect_success \
405         'git cat-file blob master:F (expect OTHER)' \
406         'test OTHER = $(git cat-file blob master:F)'
407 test_expect_success \
408         'git cat-file blob master@{2005-05-26 23:30}:F (expect TEST)' \
409         'test TEST = $(git cat-file blob "master@{2005-05-26 23:30}:F")'
410 test_expect_success \
411         'git cat-file blob master@{2005-05-26 23:42}:F (expect OTHER)' \
412         'test OTHER = $(git cat-file blob "master@{2005-05-26 23:42}:F")'
413
414 a=refs/heads/a
415 b=refs/heads/b
416 c=refs/heads/c
417 E='""'
418 F='%s\0'
419 pws='path with space'
420
421 test_expect_success 'stdin test setup' '
422         echo "$pws" >"$pws" &&
423         git add -- "$pws" &&
424         git commit -m "$pws"
425 '
426
427 test_expect_success '-z fails without --stdin' '
428         test_must_fail git update-ref -z $m $m $m 2>err &&
429         test_i18ngrep "usage: git update-ref" err
430 '
431
432 test_expect_success 'stdin works with no input' '
433         >stdin &&
434         git update-ref --stdin <stdin &&
435         git rev-parse --verify -q $m
436 '
437
438 test_expect_success 'stdin fails on empty line' '
439         echo "" >stdin &&
440         test_must_fail git update-ref --stdin <stdin 2>err &&
441         grep "fatal: empty command in input" err
442 '
443
444 test_expect_success 'stdin fails on only whitespace' '
445         echo " " >stdin &&
446         test_must_fail git update-ref --stdin <stdin 2>err &&
447         grep "fatal: whitespace before command:  " err
448 '
449
450 test_expect_success 'stdin fails on leading whitespace' '
451         echo " create $a $m" >stdin &&
452         test_must_fail git update-ref --stdin <stdin 2>err &&
453         grep "fatal: whitespace before command:  create $a $m" err
454 '
455
456 test_expect_success 'stdin fails on unknown command' '
457         echo "unknown $a" >stdin &&
458         test_must_fail git update-ref --stdin <stdin 2>err &&
459         grep "fatal: unknown command: unknown $a" err
460 '
461
462 test_expect_success 'stdin fails on unbalanced quotes' '
463         echo "create $a \"master" >stdin &&
464         test_must_fail git update-ref --stdin <stdin 2>err &&
465         grep "fatal: badly quoted argument: \\\"master" err
466 '
467
468 test_expect_success 'stdin fails on invalid escape' '
469         echo "create $a \"ma\zter\"" >stdin &&
470         test_must_fail git update-ref --stdin <stdin 2>err &&
471         grep "fatal: badly quoted argument: \\\"ma\\\\zter\\\"" err
472 '
473
474 test_expect_success 'stdin fails on junk after quoted argument' '
475         echo "create \"$a\"master" >stdin &&
476         test_must_fail git update-ref --stdin <stdin 2>err &&
477         grep "fatal: unexpected character after quoted argument: \\\"$a\\\"master" err
478 '
479
480 test_expect_success 'stdin fails create with no ref' '
481         echo "create " >stdin &&
482         test_must_fail git update-ref --stdin <stdin 2>err &&
483         grep "fatal: create: missing <ref>" err
484 '
485
486 test_expect_success 'stdin fails create with no new value' '
487         echo "create $a" >stdin &&
488         test_must_fail git update-ref --stdin <stdin 2>err &&
489         grep "fatal: create $a: missing <newvalue>" err
490 '
491
492 test_expect_success 'stdin fails create with too many arguments' '
493         echo "create $a $m $m" >stdin &&
494         test_must_fail git update-ref --stdin <stdin 2>err &&
495         grep "fatal: create $a: extra input:  $m" err
496 '
497
498 test_expect_success 'stdin fails update with no ref' '
499         echo "update " >stdin &&
500         test_must_fail git update-ref --stdin <stdin 2>err &&
501         grep "fatal: update: missing <ref>" err
502 '
503
504 test_expect_success 'stdin fails update with no new value' '
505         echo "update $a" >stdin &&
506         test_must_fail git update-ref --stdin <stdin 2>err &&
507         grep "fatal: update $a: missing <newvalue>" err
508 '
509
510 test_expect_success 'stdin fails update with too many arguments' '
511         echo "update $a $m $m $m" >stdin &&
512         test_must_fail git update-ref --stdin <stdin 2>err &&
513         grep "fatal: update $a: extra input:  $m" err
514 '
515
516 test_expect_success 'stdin fails delete with no ref' '
517         echo "delete " >stdin &&
518         test_must_fail git update-ref --stdin <stdin 2>err &&
519         grep "fatal: delete: missing <ref>" err
520 '
521
522 test_expect_success 'stdin fails delete with too many arguments' '
523         echo "delete $a $m $m" >stdin &&
524         test_must_fail git update-ref --stdin <stdin 2>err &&
525         grep "fatal: delete $a: extra input:  $m" err
526 '
527
528 test_expect_success 'stdin fails verify with too many arguments' '
529         echo "verify $a $m $m" >stdin &&
530         test_must_fail git update-ref --stdin <stdin 2>err &&
531         grep "fatal: verify $a: extra input:  $m" err
532 '
533
534 test_expect_success 'stdin fails option with unknown name' '
535         echo "option unknown" >stdin &&
536         test_must_fail git update-ref --stdin <stdin 2>err &&
537         grep "fatal: option unknown: unknown" err
538 '
539
540 test_expect_success 'stdin fails with duplicate refs' '
541         cat >stdin <<-EOF &&
542         create $a $m
543         create $b $m
544         create $a $m
545         EOF
546         test_must_fail git update-ref --stdin <stdin 2>err &&
547         grep "fatal: multiple updates for ref '"'"'$a'"'"' not allowed." err
548 '
549
550 test_expect_success 'stdin create ref works' '
551         echo "create $a $m" >stdin &&
552         git update-ref --stdin <stdin &&
553         git rev-parse $m >expect &&
554         git rev-parse $a >actual &&
555         test_cmp expect actual
556 '
557
558 test_expect_success 'stdin does not create reflogs by default' '
559         test_when_finished "git update-ref -d $outside" &&
560         echo "create $outside $m" >stdin &&
561         git update-ref --stdin <stdin &&
562         git rev-parse $m >expect &&
563         git rev-parse $outside >actual &&
564         test_cmp expect actual &&
565         test_must_fail git reflog exists $outside
566 '
567
568 test_expect_success 'stdin creates reflogs with --create-reflog' '
569         test_when_finished "git update-ref -d $outside" &&
570         echo "create $outside $m" >stdin &&
571         git update-ref --create-reflog --stdin <stdin &&
572         git rev-parse $m >expect &&
573         git rev-parse $outside >actual &&
574         test_cmp expect actual &&
575         git reflog exists $outside
576 '
577
578 test_expect_success 'stdin succeeds with quoted argument' '
579         git update-ref -d $a &&
580         echo "create $a \"$m\"" >stdin &&
581         git update-ref --stdin <stdin &&
582         git rev-parse $m >expect &&
583         git rev-parse $a >actual &&
584         test_cmp expect actual
585 '
586
587 test_expect_success 'stdin succeeds with escaped character' '
588         git update-ref -d $a &&
589         echo "create $a \"ma\\163ter\"" >stdin &&
590         git update-ref --stdin <stdin &&
591         git rev-parse $m >expect &&
592         git rev-parse $a >actual &&
593         test_cmp expect actual
594 '
595
596 test_expect_success 'stdin update ref creates with zero old value' '
597         echo "update $b $m $Z" >stdin &&
598         git update-ref --stdin <stdin &&
599         git rev-parse $m >expect &&
600         git rev-parse $b >actual &&
601         test_cmp expect actual &&
602         git update-ref -d $b
603 '
604
605 test_expect_success 'stdin update ref creates with empty old value' '
606         echo "update $b $m $E" >stdin &&
607         git update-ref --stdin <stdin &&
608         git rev-parse $m >expect &&
609         git rev-parse $b >actual &&
610         test_cmp expect actual
611 '
612
613 test_expect_success 'stdin create ref works with path with space to blob' '
614         echo "create refs/blobs/pws \"$m:$pws\"" >stdin &&
615         git update-ref --stdin <stdin &&
616         git rev-parse "$m:$pws" >expect &&
617         git rev-parse refs/blobs/pws >actual &&
618         test_cmp expect actual &&
619         git update-ref -d refs/blobs/pws
620 '
621
622 test_expect_success 'stdin update ref fails with wrong old value' '
623         echo "update $c $m $m~1" >stdin &&
624         test_must_fail git update-ref --stdin <stdin 2>err &&
625         grep "fatal: cannot lock ref '"'"'$c'"'"'" err &&
626         test_must_fail git rev-parse --verify -q $c
627 '
628
629 test_expect_success 'stdin update ref fails with bad old value' '
630         echo "update $c $m does-not-exist" >stdin &&
631         test_must_fail git update-ref --stdin <stdin 2>err &&
632         grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
633         test_must_fail git rev-parse --verify -q $c
634 '
635
636 test_expect_success 'stdin create ref fails with bad new value' '
637         echo "create $c does-not-exist" >stdin &&
638         test_must_fail git update-ref --stdin <stdin 2>err &&
639         grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
640         test_must_fail git rev-parse --verify -q $c
641 '
642
643 test_expect_success 'stdin create ref fails with zero new value' '
644         echo "create $c " >stdin &&
645         test_must_fail git update-ref --stdin <stdin 2>err &&
646         grep "fatal: create $c: zero <newvalue>" err &&
647         test_must_fail git rev-parse --verify -q $c
648 '
649
650 test_expect_success 'stdin update ref works with right old value' '
651         echo "update $b $m~1 $m" >stdin &&
652         git update-ref --stdin <stdin &&
653         git rev-parse $m~1 >expect &&
654         git rev-parse $b >actual &&
655         test_cmp expect actual
656 '
657
658 test_expect_success 'stdin delete ref fails with wrong old value' '
659         echo "delete $a $m~1" >stdin &&
660         test_must_fail git update-ref --stdin <stdin 2>err &&
661         grep "fatal: cannot lock ref '"'"'$a'"'"'" err &&
662         git rev-parse $m >expect &&
663         git rev-parse $a >actual &&
664         test_cmp expect actual
665 '
666
667 test_expect_success 'stdin delete ref fails with zero old value' '
668         echo "delete $a " >stdin &&
669         test_must_fail git update-ref --stdin <stdin 2>err &&
670         grep "fatal: delete $a: zero <oldvalue>" err &&
671         git rev-parse $m >expect &&
672         git rev-parse $a >actual &&
673         test_cmp expect actual
674 '
675
676 test_expect_success 'stdin update symref works option no-deref' '
677         git symbolic-ref TESTSYMREF $b &&
678         cat >stdin <<-EOF &&
679         option no-deref
680         update TESTSYMREF $a $b
681         EOF
682         git update-ref --stdin <stdin &&
683         git rev-parse TESTSYMREF >expect &&
684         git rev-parse $a >actual &&
685         test_cmp expect actual &&
686         git rev-parse $m~1 >expect &&
687         git rev-parse $b >actual &&
688         test_cmp expect actual
689 '
690
691 test_expect_success 'stdin delete symref works option no-deref' '
692         git symbolic-ref TESTSYMREF $b &&
693         cat >stdin <<-EOF &&
694         option no-deref
695         delete TESTSYMREF $b
696         EOF
697         git update-ref --stdin <stdin &&
698         test_must_fail git rev-parse --verify -q TESTSYMREF &&
699         git rev-parse $m~1 >expect &&
700         git rev-parse $b >actual &&
701         test_cmp expect actual
702 '
703
704 test_expect_success 'stdin delete ref works with right old value' '
705         echo "delete $b $m~1" >stdin &&
706         git update-ref --stdin <stdin &&
707         test_must_fail git rev-parse --verify -q $b
708 '
709
710 test_expect_success 'stdin update/create/verify combination works' '
711         cat >stdin <<-EOF &&
712         update $a $m
713         create $b $m
714         verify $c
715         EOF
716         git update-ref --stdin <stdin &&
717         git rev-parse $m >expect &&
718         git rev-parse $a >actual &&
719         test_cmp expect actual &&
720         git rev-parse $b >actual &&
721         test_cmp expect actual &&
722         test_must_fail git rev-parse --verify -q $c
723 '
724
725 test_expect_success 'stdin verify succeeds for correct value' '
726         git rev-parse $m >expect &&
727         echo "verify $m $m" >stdin &&
728         git update-ref --stdin <stdin &&
729         git rev-parse $m >actual &&
730         test_cmp expect actual
731 '
732
733 test_expect_success 'stdin verify succeeds for missing reference' '
734         echo "verify refs/heads/missing $Z" >stdin &&
735         git update-ref --stdin <stdin &&
736         test_must_fail git rev-parse --verify -q refs/heads/missing
737 '
738
739 test_expect_success 'stdin verify treats no value as missing' '
740         echo "verify refs/heads/missing" >stdin &&
741         git update-ref --stdin <stdin &&
742         test_must_fail git rev-parse --verify -q refs/heads/missing
743 '
744
745 test_expect_success 'stdin verify fails for wrong value' '
746         git rev-parse $m >expect &&
747         echo "verify $m $m~1" >stdin &&
748         test_must_fail git update-ref --stdin <stdin &&
749         git rev-parse $m >actual &&
750         test_cmp expect actual
751 '
752
753 test_expect_success 'stdin verify fails for mistaken null value' '
754         git rev-parse $m >expect &&
755         echo "verify $m $Z" >stdin &&
756         test_must_fail git update-ref --stdin <stdin &&
757         git rev-parse $m >actual &&
758         test_cmp expect actual
759 '
760
761 test_expect_success 'stdin verify fails for mistaken empty value' '
762         M=$(git rev-parse $m) &&
763         test_when_finished "git update-ref $m $M" &&
764         git rev-parse $m >expect &&
765         echo "verify $m" >stdin &&
766         test_must_fail git update-ref --stdin <stdin &&
767         git rev-parse $m >actual &&
768         test_cmp expect actual
769 '
770
771 test_expect_success 'stdin update refs works with identity updates' '
772         cat >stdin <<-EOF &&
773         update $a $m $m
774         update $b $m $m
775         update $c $Z $E
776         EOF
777         git update-ref --stdin <stdin &&
778         git rev-parse $m >expect &&
779         git rev-parse $a >actual &&
780         test_cmp expect actual &&
781         git rev-parse $b >actual &&
782         test_cmp expect actual &&
783         test_must_fail git rev-parse --verify -q $c
784 '
785
786 test_expect_success 'stdin update refs fails with wrong old value' '
787         git update-ref $c $m &&
788         cat >stdin <<-EOF &&
789         update $a $m $m
790         update $b $m $m
791         update $c  ''
792         EOF
793         test_must_fail git update-ref --stdin <stdin 2>err &&
794         grep "fatal: cannot lock ref '"'"'$c'"'"'" err &&
795         git rev-parse $m >expect &&
796         git rev-parse $a >actual &&
797         test_cmp expect actual &&
798         git rev-parse $b >actual &&
799         test_cmp expect actual &&
800         git rev-parse $c >actual &&
801         test_cmp expect actual
802 '
803
804 test_expect_success 'stdin delete refs works with packed and loose refs' '
805         git pack-refs --all &&
806         git update-ref $c $m~1 &&
807         cat >stdin <<-EOF &&
808         delete $a $m
809         update $b $Z $m
810         update $c $E $m~1
811         EOF
812         git update-ref --stdin <stdin &&
813         test_must_fail git rev-parse --verify -q $a &&
814         test_must_fail git rev-parse --verify -q $b &&
815         test_must_fail git rev-parse --verify -q $c
816 '
817
818 test_expect_success 'stdin -z works on empty input' '
819         >stdin &&
820         git update-ref -z --stdin <stdin &&
821         git rev-parse --verify -q $m
822 '
823
824 test_expect_success 'stdin -z fails on empty line' '
825         echo "" >stdin &&
826         test_must_fail git update-ref -z --stdin <stdin 2>err &&
827         grep "fatal: whitespace before command: " err
828 '
829
830 test_expect_success 'stdin -z fails on empty command' '
831         printf $F "" >stdin &&
832         test_must_fail git update-ref -z --stdin <stdin 2>err &&
833         grep "fatal: empty command in input" err
834 '
835
836 test_expect_success 'stdin -z fails on only whitespace' '
837         printf $F " " >stdin &&
838         test_must_fail git update-ref -z --stdin <stdin 2>err &&
839         grep "fatal: whitespace before command:  " err
840 '
841
842 test_expect_success 'stdin -z fails on leading whitespace' '
843         printf $F " create $a" "$m" >stdin &&
844         test_must_fail git update-ref -z --stdin <stdin 2>err &&
845         grep "fatal: whitespace before command:  create $a" err
846 '
847
848 test_expect_success 'stdin -z fails on unknown command' '
849         printf $F "unknown $a" >stdin &&
850         test_must_fail git update-ref -z --stdin <stdin 2>err &&
851         grep "fatal: unknown command: unknown $a" err
852 '
853
854 test_expect_success 'stdin -z fails create with no ref' '
855         printf $F "create " >stdin &&
856         test_must_fail git update-ref -z --stdin <stdin 2>err &&
857         grep "fatal: create: missing <ref>" err
858 '
859
860 test_expect_success 'stdin -z fails create with no new value' '
861         printf $F "create $a" >stdin &&
862         test_must_fail git update-ref -z --stdin <stdin 2>err &&
863         grep "fatal: create $a: unexpected end of input when reading <newvalue>" err
864 '
865
866 test_expect_success 'stdin -z fails create with too many arguments' '
867         printf $F "create $a" "$m" "$m" >stdin &&
868         test_must_fail git update-ref -z --stdin <stdin 2>err &&
869         grep "fatal: unknown command: $m" err
870 '
871
872 test_expect_success 'stdin -z fails update with no ref' '
873         printf $F "update " >stdin &&
874         test_must_fail git update-ref -z --stdin <stdin 2>err &&
875         grep "fatal: update: missing <ref>" err
876 '
877
878 test_expect_success 'stdin -z fails update with too few args' '
879         printf $F "update $a" "$m" >stdin &&
880         test_must_fail git update-ref -z --stdin <stdin 2>err &&
881         grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
882 '
883
884 test_expect_success 'stdin -z emits warning with empty new value' '
885         git update-ref $a $m &&
886         printf $F "update $a" "" "" >stdin &&
887         git update-ref -z --stdin <stdin 2>err &&
888         grep "warning: update $a: missing <newvalue>, treating as zero" err &&
889         test_must_fail git rev-parse --verify -q $a
890 '
891
892 test_expect_success 'stdin -z fails update with no new value' '
893         printf $F "update $a" >stdin &&
894         test_must_fail git update-ref -z --stdin <stdin 2>err &&
895         grep "fatal: update $a: unexpected end of input when reading <newvalue>" err
896 '
897
898 test_expect_success 'stdin -z fails update with no old value' '
899         printf $F "update $a" "$m" >stdin &&
900         test_must_fail git update-ref -z --stdin <stdin 2>err &&
901         grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
902 '
903
904 test_expect_success 'stdin -z fails update with too many arguments' '
905         printf $F "update $a" "$m" "$m" "$m" >stdin &&
906         test_must_fail git update-ref -z --stdin <stdin 2>err &&
907         grep "fatal: unknown command: $m" err
908 '
909
910 test_expect_success 'stdin -z fails delete with no ref' '
911         printf $F "delete " >stdin &&
912         test_must_fail git update-ref -z --stdin <stdin 2>err &&
913         grep "fatal: delete: missing <ref>" err
914 '
915
916 test_expect_success 'stdin -z fails delete with no old value' '
917         printf $F "delete $a" >stdin &&
918         test_must_fail git update-ref -z --stdin <stdin 2>err &&
919         grep "fatal: delete $a: unexpected end of input when reading <oldvalue>" err
920 '
921
922 test_expect_success 'stdin -z fails delete with too many arguments' '
923         printf $F "delete $a" "$m" "$m" >stdin &&
924         test_must_fail git update-ref -z --stdin <stdin 2>err &&
925         grep "fatal: unknown command: $m" err
926 '
927
928 test_expect_success 'stdin -z fails verify with too many arguments' '
929         printf $F "verify $a" "$m" "$m" >stdin &&
930         test_must_fail git update-ref -z --stdin <stdin 2>err &&
931         grep "fatal: unknown command: $m" err
932 '
933
934 test_expect_success 'stdin -z fails verify with no old value' '
935         printf $F "verify $a" >stdin &&
936         test_must_fail git update-ref -z --stdin <stdin 2>err &&
937         grep "fatal: verify $a: unexpected end of input when reading <oldvalue>" err
938 '
939
940 test_expect_success 'stdin -z fails option with unknown name' '
941         printf $F "option unknown" >stdin &&
942         test_must_fail git update-ref -z --stdin <stdin 2>err &&
943         grep "fatal: option unknown: unknown" err
944 '
945
946 test_expect_success 'stdin -z fails with duplicate refs' '
947         printf $F "create $a" "$m" "create $b" "$m" "create $a" "$m" >stdin &&
948         test_must_fail git update-ref -z --stdin <stdin 2>err &&
949         grep "fatal: multiple updates for ref '"'"'$a'"'"' not allowed." err
950 '
951
952 test_expect_success 'stdin -z create ref works' '
953         printf $F "create $a" "$m" >stdin &&
954         git update-ref -z --stdin <stdin &&
955         git rev-parse $m >expect &&
956         git rev-parse $a >actual &&
957         test_cmp expect actual
958 '
959
960 test_expect_success 'stdin -z update ref creates with zero old value' '
961         printf $F "update $b" "$m" "$Z" >stdin &&
962         git update-ref -z --stdin <stdin &&
963         git rev-parse $m >expect &&
964         git rev-parse $b >actual &&
965         test_cmp expect actual &&
966         git update-ref -d $b
967 '
968
969 test_expect_success 'stdin -z update ref creates with empty old value' '
970         printf $F "update $b" "$m" "" >stdin &&
971         git update-ref -z --stdin <stdin &&
972         git rev-parse $m >expect &&
973         git rev-parse $b >actual &&
974         test_cmp expect actual
975 '
976
977 test_expect_success 'stdin -z create ref works with path with space to blob' '
978         printf $F "create refs/blobs/pws" "$m:$pws" >stdin &&
979         git update-ref -z --stdin <stdin &&
980         git rev-parse "$m:$pws" >expect &&
981         git rev-parse refs/blobs/pws >actual &&
982         test_cmp expect actual &&
983         git update-ref -d refs/blobs/pws
984 '
985
986 test_expect_success 'stdin -z update ref fails with wrong old value' '
987         printf $F "update $c" "$m" "$m~1" >stdin &&
988         test_must_fail git update-ref -z --stdin <stdin 2>err &&
989         grep "fatal: cannot lock ref '"'"'$c'"'"'" err &&
990         test_must_fail git rev-parse --verify -q $c
991 '
992
993 test_expect_success 'stdin -z update ref fails with bad old value' '
994         printf $F "update $c" "$m" "does-not-exist" >stdin &&
995         test_must_fail git update-ref -z --stdin <stdin 2>err &&
996         grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
997         test_must_fail git rev-parse --verify -q $c
998 '
999
1000 test_expect_success 'stdin -z create ref fails when ref exists' '
1001         git update-ref $c $m &&
1002         git rev-parse "$c" >expect &&
1003         printf $F "create $c" "$m~1" >stdin &&
1004         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1005         grep "fatal: cannot lock ref '"'"'$c'"'"'" err &&
1006         git rev-parse "$c" >actual &&
1007         test_cmp expect actual
1008 '
1009
1010 test_expect_success 'stdin -z create ref fails with bad new value' '
1011         git update-ref -d "$c" &&
1012         printf $F "create $c" "does-not-exist" >stdin &&
1013         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1014         grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
1015         test_must_fail git rev-parse --verify -q $c
1016 '
1017
1018 test_expect_success 'stdin -z create ref fails with empty new value' '
1019         printf $F "create $c" "" >stdin &&
1020         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1021         grep "fatal: create $c: missing <newvalue>" err &&
1022         test_must_fail git rev-parse --verify -q $c
1023 '
1024
1025 test_expect_success 'stdin -z update ref works with right old value' '
1026         printf $F "update $b" "$m~1" "$m" >stdin &&
1027         git update-ref -z --stdin <stdin &&
1028         git rev-parse $m~1 >expect &&
1029         git rev-parse $b >actual &&
1030         test_cmp expect actual
1031 '
1032
1033 test_expect_success 'stdin -z delete ref fails with wrong old value' '
1034         printf $F "delete $a" "$m~1" >stdin &&
1035         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1036         grep "fatal: cannot lock ref '"'"'$a'"'"'" err &&
1037         git rev-parse $m >expect &&
1038         git rev-parse $a >actual &&
1039         test_cmp expect actual
1040 '
1041
1042 test_expect_success 'stdin -z delete ref fails with zero old value' '
1043         printf $F "delete $a" "$Z" >stdin &&
1044         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1045         grep "fatal: delete $a: zero <oldvalue>" err &&
1046         git rev-parse $m >expect &&
1047         git rev-parse $a >actual &&
1048         test_cmp expect actual
1049 '
1050
1051 test_expect_success 'stdin -z update symref works option no-deref' '
1052         git symbolic-ref TESTSYMREF $b &&
1053         printf $F "option no-deref" "update TESTSYMREF" "$a" "$b" >stdin &&
1054         git update-ref -z --stdin <stdin &&
1055         git rev-parse TESTSYMREF >expect &&
1056         git rev-parse $a >actual &&
1057         test_cmp expect actual &&
1058         git rev-parse $m~1 >expect &&
1059         git rev-parse $b >actual &&
1060         test_cmp expect actual
1061 '
1062
1063 test_expect_success 'stdin -z delete symref works option no-deref' '
1064         git symbolic-ref TESTSYMREF $b &&
1065         printf $F "option no-deref" "delete TESTSYMREF" "$b" >stdin &&
1066         git update-ref -z --stdin <stdin &&
1067         test_must_fail git rev-parse --verify -q TESTSYMREF &&
1068         git rev-parse $m~1 >expect &&
1069         git rev-parse $b >actual &&
1070         test_cmp expect actual
1071 '
1072
1073 test_expect_success 'stdin -z delete ref works with right old value' '
1074         printf $F "delete $b" "$m~1" >stdin &&
1075         git update-ref -z --stdin <stdin &&
1076         test_must_fail git rev-parse --verify -q $b
1077 '
1078
1079 test_expect_success 'stdin -z update/create/verify combination works' '
1080         printf $F "update $a" "$m" "" "create $b" "$m" "verify $c" "" >stdin &&
1081         git update-ref -z --stdin <stdin &&
1082         git rev-parse $m >expect &&
1083         git rev-parse $a >actual &&
1084         test_cmp expect actual &&
1085         git rev-parse $b >actual &&
1086         test_cmp expect actual &&
1087         test_must_fail git rev-parse --verify -q $c
1088 '
1089
1090 test_expect_success 'stdin -z verify succeeds for correct value' '
1091         git rev-parse $m >expect &&
1092         printf $F "verify $m" "$m" >stdin &&
1093         git update-ref -z --stdin <stdin &&
1094         git rev-parse $m >actual &&
1095         test_cmp expect actual
1096 '
1097
1098 test_expect_success 'stdin -z verify succeeds for missing reference' '
1099         printf $F "verify refs/heads/missing" "$Z" >stdin &&
1100         git update-ref -z --stdin <stdin &&
1101         test_must_fail git rev-parse --verify -q refs/heads/missing
1102 '
1103
1104 test_expect_success 'stdin -z verify treats no value as missing' '
1105         printf $F "verify refs/heads/missing" "" >stdin &&
1106         git update-ref -z --stdin <stdin &&
1107         test_must_fail git rev-parse --verify -q refs/heads/missing
1108 '
1109
1110 test_expect_success 'stdin -z verify fails for wrong value' '
1111         git rev-parse $m >expect &&
1112         printf $F "verify $m" "$m~1" >stdin &&
1113         test_must_fail git update-ref -z --stdin <stdin &&
1114         git rev-parse $m >actual &&
1115         test_cmp expect actual
1116 '
1117
1118 test_expect_success 'stdin -z verify fails for mistaken null value' '
1119         git rev-parse $m >expect &&
1120         printf $F "verify $m" "$Z" >stdin &&
1121         test_must_fail git update-ref -z --stdin <stdin &&
1122         git rev-parse $m >actual &&
1123         test_cmp expect actual
1124 '
1125
1126 test_expect_success 'stdin -z verify fails for mistaken empty value' '
1127         M=$(git rev-parse $m) &&
1128         test_when_finished "git update-ref $m $M" &&
1129         git rev-parse $m >expect &&
1130         printf $F "verify $m" "" >stdin &&
1131         test_must_fail git update-ref -z --stdin <stdin &&
1132         git rev-parse $m >actual &&
1133         test_cmp expect actual
1134 '
1135
1136 test_expect_success 'stdin -z update refs works with identity updates' '
1137         printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$Z" "" >stdin &&
1138         git update-ref -z --stdin <stdin &&
1139         git rev-parse $m >expect &&
1140         git rev-parse $a >actual &&
1141         test_cmp expect actual &&
1142         git rev-parse $b >actual &&
1143         test_cmp expect actual &&
1144         test_must_fail git rev-parse --verify -q $c
1145 '
1146
1147 test_expect_success 'stdin -z update refs fails with wrong old value' '
1148         git update-ref $c $m &&
1149         printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$m" "$Z" >stdin &&
1150         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1151         grep "fatal: cannot lock ref '"'"'$c'"'"'" err &&
1152         git rev-parse $m >expect &&
1153         git rev-parse $a >actual &&
1154         test_cmp expect actual &&
1155         git rev-parse $b >actual &&
1156         test_cmp expect actual &&
1157         git rev-parse $c >actual &&
1158         test_cmp expect actual
1159 '
1160
1161 test_expect_success 'stdin -z delete refs works with packed and loose refs' '
1162         git pack-refs --all &&
1163         git update-ref $c $m~1 &&
1164         printf $F "delete $a" "$m" "update $b" "$Z" "$m" "update $c" "" "$m~1" >stdin &&
1165         git update-ref -z --stdin <stdin &&
1166         test_must_fail git rev-parse --verify -q $a &&
1167         test_must_fail git rev-parse --verify -q $b &&
1168         test_must_fail git rev-parse --verify -q $c
1169 '
1170
1171 test_expect_success 'fails with duplicate HEAD update' '
1172         git branch target1 $A &&
1173         git checkout target1 &&
1174         cat >stdin <<-EOF &&
1175         update refs/heads/target1 $C
1176         option no-deref
1177         update HEAD $B
1178         EOF
1179         test_must_fail git update-ref --stdin <stdin 2>err &&
1180         grep "fatal: multiple updates for '\''HEAD'\'' (including one via its referent .refs/heads/target1.) are not allowed" err &&
1181         echo "refs/heads/target1" >expect &&
1182         git symbolic-ref HEAD >actual &&
1183         test_cmp expect actual &&
1184         echo "$A" >expect &&
1185         git rev-parse refs/heads/target1 >actual &&
1186         test_cmp expect actual
1187 '
1188
1189 test_expect_success 'fails with duplicate ref update via symref' '
1190         git branch target2 $A &&
1191         git symbolic-ref refs/heads/symref2 refs/heads/target2 &&
1192         cat >stdin <<-EOF &&
1193         update refs/heads/target2 $C
1194         update refs/heads/symref2 $B
1195         EOF
1196         test_must_fail git update-ref --stdin <stdin 2>err &&
1197         grep "fatal: multiple updates for '\''refs/heads/target2'\'' (including one via symref .refs/heads/symref2.) are not allowed" err &&
1198         echo "refs/heads/target2" >expect &&
1199         git symbolic-ref refs/heads/symref2 >actual &&
1200         test_cmp expect actual &&
1201         echo "$A" >expect &&
1202         git rev-parse refs/heads/target2 >actual &&
1203         test_cmp expect actual
1204 '
1205
1206 run_with_limited_open_files () {
1207         (ulimit -n 32 && "$@")
1208 }
1209
1210 test_lazy_prereq ULIMIT_FILE_DESCRIPTORS 'run_with_limited_open_files true'
1211
1212 test_expect_success ULIMIT_FILE_DESCRIPTORS 'large transaction creating branches does not burst open file limit' '
1213 (
1214         for i in $(test_seq 33)
1215         do
1216                 echo "create refs/heads/$i HEAD"
1217         done >large_input &&
1218         run_with_limited_open_files git update-ref --stdin <large_input &&
1219         git rev-parse --verify -q refs/heads/33
1220 )
1221 '
1222
1223 test_expect_success ULIMIT_FILE_DESCRIPTORS 'large transaction deleting branches does not burst open file limit' '
1224 (
1225         for i in $(test_seq 33)
1226         do
1227                 echo "delete refs/heads/$i HEAD"
1228         done >large_input &&
1229         run_with_limited_open_files git update-ref --stdin <large_input &&
1230         test_must_fail git rev-parse --verify -q refs/heads/33
1231 )
1232 '
1233
1234 test_expect_success 'handle per-worktree refs in refs/bisect' '
1235         git commit --allow-empty -m "initial commit" &&
1236         git worktree add -b branch worktree &&
1237         (
1238                 cd worktree &&
1239                 git commit --allow-empty -m "test commit"  &&
1240                 git for-each-ref >for-each-ref.out &&
1241                 ! grep refs/bisect for-each-ref.out &&
1242                 git update-ref refs/bisect/something HEAD &&
1243                 git rev-parse refs/bisect/something >../worktree-head &&
1244                 git for-each-ref | grep refs/bisect/something
1245         ) &&
1246         test_path_is_missing .git/refs/bisect &&
1247         test_must_fail git rev-parse refs/bisect/something &&
1248         git update-ref refs/bisect/something HEAD &&
1249         git rev-parse refs/bisect/something >main-head &&
1250         ! test_cmp main-head worktree-head
1251 '
1252
1253 test_done