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