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