t/t7508-status.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Johannes E. Schindelin
   4 #
   5
   6 test_description='git status'
   7
   8 . ./test-lib.sh
   9 . "$TEST_DIRECTORY"/lib-terminal.sh
  10
  11 test_expect_success 'status -h in broken repository' '
  12         git config --global advice.statusuoption false &&
  13         mkdir broken &&
  14         test_when_finished "rm -fr broken" &&
  15         (
  16                 cd broken &&
  17                 git init &&
  18                 echo "[status] showuntrackedfiles = CORRUPT" >>.git/config &&
  19                 test_expect_code 129 git status -h >usage 2>&1
  20         ) &&
  21         test_i18ngrep "[Uu]sage" broken/usage
  22 '
  23
  24 test_expect_success 'commit -h in broken repository' '
  25         mkdir broken &&
  26         test_when_finished "rm -fr broken" &&
  27         (
  28                 cd broken &&
  29                 git init &&
  30                 echo "[status] showuntrackedfiles = CORRUPT" >>.git/config &&
  31                 test_expect_code 129 git commit -h >usage 2>&1
  32         ) &&
  33         test_i18ngrep "[Uu]sage" broken/usage
  34 '
  35
  36 test_expect_success 'create upstream branch' '
  37         git checkout -b upstream &&
  38         test_commit upstream1 &&
  39         test_commit upstream2 &&
  40         # leave the first commit on master as root because several
  41         # tests depend on this case; for our upstream we only
  42         # care about commit counts anyway, so a totally divergent
  43         # history is OK
  44         git checkout --orphan master
  45 '
  46
  47 test_expect_success 'setup' '
  48         : >tracked &&
  49         : >modified &&
  50         mkdir dir1 &&
  51         : >dir1/tracked &&
  52         : >dir1/modified &&
  53         mkdir dir2 &&
  54         : >dir1/tracked &&
  55         : >dir1/modified &&
  56         git add . &&
  57
  58         git status >output &&
  59
  60         test_tick &&
  61         git commit -m initial &&
  62         : >untracked &&
  63         : >dir1/untracked &&
  64         : >dir2/untracked &&
  65         echo 1 >dir1/modified &&
  66         echo 2 >dir2/modified &&
  67         echo 3 >dir2/added &&
  68         git add dir2/added &&
  69
  70         git branch --set-upstream-to=upstream
  71 '
  72
  73 test_expect_success 'status (1)' '
  74         test_i18ngrep "use \"git rm --cached <file>\.\.\.\" to unstage" output
  75 '
  76
  77 strip_comments () {
  78         tab='   '
  79         sed "s/^\# //; s/^\#$//; s/^#$tab/$tab/" <"$1" >"$1".tmp &&
  80         rm "$1" && mv "$1".tmp "$1"
  81 }
  82
  83 cat >.gitignore <<\EOF
  84 .gitignore
  85 expect*
  86 output*
  87 EOF
  88
  89 test_expect_success 'status --column' '
  90         cat >expect <<\EOF &&
  91 # On branch master
  92 # Your branch and '\''upstream'\'' have diverged,
  93 # and have 1 and 2 different commits each, respectively.
  94 #   (use "git pull" to merge the remote branch into yours)
  95 #
  96 # Changes to be committed:
  97 #   (use "git restore --staged <file>..." to unstage)
  98 #       new file:   dir2/added
  99 #
 100 # Changes not staged for commit:
 101 #   (use "git add <file>..." to update what will be committed)
 102 #   (use "git restore <file>..." to discard changes in working directory)
 103 #       modified:   dir1/modified
 104 #
 105 # Untracked files:
 106 #   (use "git add <file>..." to include in what will be committed)
 107 #       dir1/untracked dir2/untracked
 108 #       dir2/modified  untracked
 109 #
 110 EOF
 111         COLUMNS=50 git -c status.displayCommentPrefix=true status --column="column dense" >output &&
 112         test_i18ncmp expect output
 113 '
 114
 115 test_expect_success 'status --column status.displayCommentPrefix=false' '
 116         strip_comments expect &&
 117         COLUMNS=49 git -c status.displayCommentPrefix=false status --column="column dense" >output &&
 118         test_i18ncmp expect output
 119 '
 120
 121 cat >expect <<\EOF
 122 # On branch master
 123 # Your branch and 'upstream' have diverged,
 124 # and have 1 and 2 different commits each, respectively.
 125 #   (use "git pull" to merge the remote branch into yours)
 126 #
 127 # Changes to be committed:
 128 #   (use "git restore --staged <file>..." to unstage)
 129 #       new file:   dir2/added
 130 #
 131 # Changes not staged for commit:
 132 #   (use "git add <file>..." to update what will be committed)
 133 #   (use "git restore <file>..." to discard changes in working directory)
 134 #       modified:   dir1/modified
 135 #
 136 # Untracked files:
 137 #   (use "git add <file>..." to include in what will be committed)
 138 #       dir1/untracked
 139 #       dir2/modified
 140 #       dir2/untracked
 141 #       untracked
 142 #
 143 EOF
 144
 145 test_expect_success 'status with status.displayCommentPrefix=true' '
 146         git -c status.displayCommentPrefix=true status >output &&
 147         test_i18ncmp expect output
 148 '
 149
 150 test_expect_success 'status with status.displayCommentPrefix=false' '
 151         strip_comments expect &&
 152         git -c status.displayCommentPrefix=false status >output &&
 153         test_i18ncmp expect output
 154 '
 155
 156 test_expect_success 'status -v' '
 157         (cat expect && git diff --cached) >expect-with-v &&
 158         git status -v >output &&
 159         test_i18ncmp expect-with-v output
 160 '
 161
 162 test_expect_success 'status -v -v' '
 163         (cat expect &&
 164          echo "Changes to be committed:" &&
 165          git -c diff.mnemonicprefix=true diff --cached &&
 166          echo "--------------------------------------------------" &&
 167          echo "Changes not staged for commit:" &&
 168          git -c diff.mnemonicprefix=true diff) >expect-with-v &&
 169         git status -v -v >output &&
 170         test_i18ncmp expect-with-v output
 171 '
 172
 173 test_expect_success 'setup fake editor' '
 174         cat >.git/editor <<-\EOF &&
 175         #! /bin/sh
 176         cp "$1" output
 177 EOF
 178         chmod 755 .git/editor
 179 '
 180
 181 commit_template_commented () {
 182         (
 183                 EDITOR=.git/editor &&
 184                 export EDITOR &&
 185                 # Fails due to empty message
 186                 test_must_fail git commit
 187         ) &&
 188         ! grep '^[^#]' output
 189 }
 190
 191 test_expect_success 'commit ignores status.displayCommentPrefix=false in COMMIT_EDITMSG' '
 192         commit_template_commented
 193 '
 194
 195 cat >expect <<\EOF
 196 On branch master
 197 Your branch and 'upstream' have diverged,
 198 and have 1 and 2 different commits each, respectively.
 199
 200 Changes to be committed:
 201         new file:   dir2/added
 202
 203 Changes not staged for commit:
 204         modified:   dir1/modified
 205
 206 Untracked files:
 207         dir1/untracked
 208         dir2/modified
 209         dir2/untracked
 210         untracked
 211
 212 EOF
 213
 214 test_expect_success 'status (advice.statusHints false)' '
 215         test_config advice.statusHints false &&
 216         git status >output &&
 217         test_i18ncmp expect output
 218
 219 '
 220
 221 cat >expect <<\EOF
 222  M dir1/modified
 223 A  dir2/added
 224 ?? dir1/untracked
 225 ?? dir2/modified
 226 ?? dir2/untracked
 227 ?? untracked
 228 EOF
 229
 230 test_expect_success 'status -s' '
 231
 232         git status -s >output &&
 233         test_cmp expect output
 234
 235 '
 236
 237 test_expect_success 'status with gitignore' '
 238         {
 239                 echo ".gitignore" &&
 240                 echo "expect*" &&
 241                 echo "output" &&
 242                 echo "untracked"
 243         } >.gitignore &&
 244
 245         cat >expect <<-\EOF &&
 246          M dir1/modified
 247         A  dir2/added
 248         ?? dir2/modified
 249         EOF
 250         git status -s >output &&
 251         test_cmp expect output &&
 252
 253         cat >expect <<-\EOF &&
 254          M dir1/modified
 255         A  dir2/added
 256         ?? dir2/modified
 257         !! .gitignore
 258         !! dir1/untracked
 259         !! dir2/untracked
 260         !! expect
 261         !! expect-with-v
 262         !! output
 263         !! untracked
 264         EOF
 265         git status -s --ignored >output &&
 266         test_cmp expect output &&
 267
 268         cat >expect <<\EOF &&
 269 On branch master
 270 Your branch and '\''upstream'\'' have diverged,
 271 and have 1 and 2 different commits each, respectively.
 272   (use "git pull" to merge the remote branch into yours)
 273
 274 Changes to be committed:
 275   (use "git restore --staged <file>..." to unstage)
 276         new file:   dir2/added
 277
 278 Changes not staged for commit:
 279   (use "git add <file>..." to update what will be committed)
 280   (use "git restore <file>..." to discard changes in working directory)
 281         modified:   dir1/modified
 282
 283 Untracked files:
 284   (use "git add <file>..." to include in what will be committed)
 285         dir2/modified
 286
 287 Ignored files:
 288   (use "git add -f <file>..." to include in what will be committed)
 289         .gitignore
 290         dir1/untracked
 291         dir2/untracked
 292         expect
 293         expect-with-v
 294         output
 295         untracked
 296
 297 EOF
 298         git status --ignored >output &&
 299         test_i18ncmp expect output
 300 '
 301
 302 test_expect_success 'status with gitignore (nothing untracked)' '
 303         {
 304                 echo ".gitignore" &&
 305                 echo "expect*" &&
 306                 echo "dir2/modified" &&
 307                 echo "output" &&
 308                 echo "untracked"
 309         } >.gitignore &&
 310
 311         cat >expect <<-\EOF &&
 312          M dir1/modified
 313         A  dir2/added
 314         EOF
 315         git status -s >output &&
 316         test_cmp expect output &&
 317
 318         cat >expect <<-\EOF &&
 319          M dir1/modified
 320         A  dir2/added
 321         !! .gitignore
 322         !! dir1/untracked
 323         !! dir2/modified
 324         !! dir2/untracked
 325         !! expect
 326         !! expect-with-v
 327         !! output
 328         !! untracked
 329         EOF
 330         git status -s --ignored >output &&
 331         test_cmp expect output &&
 332
 333         cat >expect <<\EOF &&
 334 On branch master
 335 Your branch and '\''upstream'\'' have diverged,
 336 and have 1 and 2 different commits each, respectively.
 337   (use "git pull" to merge the remote branch into yours)
 338
 339 Changes to be committed:
 340   (use "git restore --staged <file>..." to unstage)
 341         new file:   dir2/added
 342
 343 Changes not staged for commit:
 344   (use "git add <file>..." to update what will be committed)
 345   (use "git restore <file>..." to discard changes in working directory)
 346         modified:   dir1/modified
 347
 348 Ignored files:
 349   (use "git add -f <file>..." to include in what will be committed)
 350         .gitignore
 351         dir1/untracked
 352         dir2/modified
 353         dir2/untracked
 354         expect
 355         expect-with-v
 356         output
 357         untracked
 358
 359 EOF
 360         git status --ignored >output &&
 361         test_i18ncmp expect output
 362 '
 363
 364 cat >.gitignore <<\EOF
 365 .gitignore
 366 expect*
 367 output*
 368 EOF
 369
 370 cat >expect <<\EOF
 371 ## master...upstream [ahead 1, behind 2]
 372  M dir1/modified
 373 A  dir2/added
 374 ?? dir1/untracked
 375 ?? dir2/modified
 376 ?? dir2/untracked
 377 ?? untracked
 378 EOF
 379
 380 test_expect_success 'status -s -b' '
 381
 382         git status -s -b >output &&
 383         test_i18ncmp expect output
 384
 385 '
 386
 387 test_expect_success 'status -s -z -b' '
 388         tr "\\n" Q <expect >expect.q &&
 389         mv expect.q expect &&
 390         git status -s -z -b >output &&
 391         nul_to_q <output >output.q &&
 392         mv output.q output &&
 393         test_i18ncmp expect output
 394 '
 395
 396 test_expect_success 'setup dir3' '
 397         mkdir dir3 &&
 398         : >dir3/untracked1 &&
 399         : >dir3/untracked2
 400 '
 401
 402 test_expect_success 'status -uno' '
 403         cat >expect <<EOF &&
 404 On branch master
 405 Your branch and '\''upstream'\'' have diverged,
 406 and have 1 and 2 different commits each, respectively.
 407   (use "git pull" to merge the remote branch into yours)
 408
 409 Changes to be committed:
 410   (use "git restore --staged <file>..." to unstage)
 411         new file:   dir2/added
 412
 413 Changes not staged for commit:
 414   (use "git add <file>..." to update what will be committed)
 415   (use "git restore <file>..." to discard changes in working directory)
 416         modified:   dir1/modified
 417
 418 Untracked files not listed (use -u option to show untracked files)
 419 EOF
 420         git status -uno >output &&
 421         test_i18ncmp expect output
 422 '
 423
 424 test_expect_success 'status (status.showUntrackedFiles no)' '
 425         test_config status.showuntrackedfiles no &&
 426         git status >output &&
 427         test_i18ncmp expect output
 428 '
 429
 430 test_expect_success 'status -uno (advice.statusHints false)' '
 431         cat >expect <<EOF &&
 432 On branch master
 433 Your branch and '\''upstream'\'' have diverged,
 434 and have 1 and 2 different commits each, respectively.
 435
 436 Changes to be committed:
 437         new file:   dir2/added
 438
 439 Changes not staged for commit:
 440         modified:   dir1/modified
 441
 442 Untracked files not listed
 443 EOF
 444         test_config advice.statusHints false &&
 445         git status -uno >output &&
 446         test_i18ncmp expect output
 447 '
 448
 449 cat >expect << EOF
 450  M dir1/modified
 451 A  dir2/added
 452 EOF
 453 test_expect_success 'status -s -uno' '
 454         git status -s -uno >output &&
 455         test_cmp expect output
 456 '
 457
 458 test_expect_success 'status -s (status.showUntrackedFiles no)' '
 459         git config status.showuntrackedfiles no &&
 460         git status -s >output &&
 461         test_cmp expect output
 462 '
 463
 464 test_expect_success 'status -unormal' '
 465         cat >expect <<EOF &&
 466 On branch master
 467 Your branch and '\''upstream'\'' have diverged,
 468 and have 1 and 2 different commits each, respectively.
 469   (use "git pull" to merge the remote branch into yours)
 470
 471 Changes to be committed:
 472   (use "git restore --staged <file>..." to unstage)
 473         new file:   dir2/added
 474
 475 Changes not staged for commit:
 476   (use "git add <file>..." to update what will be committed)
 477   (use "git restore <file>..." to discard changes in working directory)
 478         modified:   dir1/modified
 479
 480 Untracked files:
 481   (use "git add <file>..." to include in what will be committed)
 482         dir1/untracked
 483         dir2/modified
 484         dir2/untracked
 485         dir3/
 486         untracked
 487
 488 EOF
 489         git status -unormal >output &&
 490         test_i18ncmp expect output
 491 '
 492
 493 test_expect_success 'status (status.showUntrackedFiles normal)' '
 494         test_config status.showuntrackedfiles normal &&
 495         git status >output &&
 496         test_i18ncmp expect output
 497 '
 498
 499 cat >expect <<EOF
 500  M dir1/modified
 501 A  dir2/added
 502 ?? dir1/untracked
 503 ?? dir2/modified
 504 ?? dir2/untracked
 505 ?? dir3/
 506 ?? untracked
 507 EOF
 508 test_expect_success 'status -s -unormal' '
 509         git status -s -unormal >output &&
 510         test_cmp expect output
 511 '
 512
 513 test_expect_success 'status -s (status.showUntrackedFiles normal)' '
 514         git config status.showuntrackedfiles normal &&
 515         git status -s >output &&
 516         test_cmp expect output
 517 '
 518
 519 test_expect_success 'status -uall' '
 520         cat >expect <<EOF &&
 521 On branch master
 522 Your branch and '\''upstream'\'' have diverged,
 523 and have 1 and 2 different commits each, respectively.
 524   (use "git pull" to merge the remote branch into yours)
 525
 526 Changes to be committed:
 527   (use "git restore --staged <file>..." to unstage)
 528         new file:   dir2/added
 529
 530 Changes not staged for commit:
 531   (use "git add <file>..." to update what will be committed)
 532   (use "git restore <file>..." to discard changes in working directory)
 533         modified:   dir1/modified
 534
 535 Untracked files:
 536   (use "git add <file>..." to include in what will be committed)
 537         dir1/untracked
 538         dir2/modified
 539         dir2/untracked
 540         dir3/untracked1
 541         dir3/untracked2
 542         untracked
 543
 544 EOF
 545         git status -uall >output &&
 546         test_i18ncmp expect output
 547 '
 548
 549 test_expect_success 'status (status.showUntrackedFiles all)' '
 550         test_config status.showuntrackedfiles all &&
 551         git status >output &&
 552         test_i18ncmp expect output
 553 '
 554
 555 test_expect_success 'teardown dir3' '
 556         rm -rf dir3
 557 '
 558
 559 cat >expect <<EOF
 560  M dir1/modified
 561 A  dir2/added
 562 ?? dir1/untracked
 563 ?? dir2/modified
 564 ?? dir2/untracked
 565 ?? untracked
 566 EOF
 567 test_expect_success 'status -s -uall' '
 568         test_unconfig status.showuntrackedfiles &&
 569         git status -s -uall >output &&
 570         test_cmp expect output
 571 '
 572 test_expect_success 'status -s (status.showUntrackedFiles all)' '
 573         test_config status.showuntrackedfiles all &&
 574         git status -s >output &&
 575         rm -rf dir3 &&
 576         test_cmp expect output
 577 '
 578
 579 test_expect_success 'status with relative paths' '
 580         cat >expect <<\EOF &&
 581 On branch master
 582 Your branch and '\''upstream'\'' have diverged,
 583 and have 1 and 2 different commits each, respectively.
 584   (use "git pull" to merge the remote branch into yours)
 585
 586 Changes to be committed:
 587   (use "git restore --staged <file>..." to unstage)
 588         new file:   ../dir2/added
 589
 590 Changes not staged for commit:
 591   (use "git add <file>..." to update what will be committed)
 592   (use "git restore <file>..." to discard changes in working directory)
 593         modified:   modified
 594
 595 Untracked files:
 596   (use "git add <file>..." to include in what will be committed)
 597         untracked
 598         ../dir2/modified
 599         ../dir2/untracked
 600         ../untracked
 601
 602 EOF
 603         (cd dir1 && git status) >output &&
 604         test_i18ncmp expect output
 605 '
 606
 607 cat >expect <<\EOF
 608  M modified
 609 A  ../dir2/added
 610 ?? untracked
 611 ?? ../dir2/modified
 612 ?? ../dir2/untracked
 613 ?? ../untracked
 614 EOF
 615 test_expect_success 'status -s with relative paths' '
 616
 617         (cd dir1 && git status -s) >output &&
 618         test_cmp expect output
 619
 620 '
 621
 622 cat >expect <<\EOF
 623  M dir1/modified
 624 A  dir2/added
 625 ?? dir1/untracked
 626 ?? dir2/modified
 627 ?? dir2/untracked
 628 ?? untracked
 629 EOF
 630
 631 test_expect_success 'status --porcelain ignores relative paths setting' '
 632
 633         (cd dir1 && git status --porcelain) >output &&
 634         test_cmp expect output
 635
 636 '
 637
 638 test_expect_success 'setup unique colors' '
 639
 640         git config status.color.untracked blue &&
 641         git config status.color.branch green &&
 642         git config status.color.localBranch yellow &&
 643         git config status.color.remoteBranch cyan
 644
 645 '
 646
 647 test_expect_success TTY 'status with color.ui' '
 648         cat >expect <<\EOF &&
 649 On branch <GREEN>master<RESET>
 650 Your branch and '\''upstream'\'' have diverged,
 651 and have 1 and 2 different commits each, respectively.
 652   (use "git pull" to merge the remote branch into yours)
 653
 654 Changes to be committed:
 655   (use "git restore --staged <file>..." to unstage)
 656         <GREEN>new file:   dir2/added<RESET>
 657
 658 Changes not staged for commit:
 659   (use "git add <file>..." to update what will be committed)
 660   (use "git restore <file>..." to discard changes in working directory)
 661         <RED>modified:   dir1/modified<RESET>
 662
 663 Untracked files:
 664   (use "git add <file>..." to include in what will be committed)
 665         <BLUE>dir1/untracked<RESET>
 666         <BLUE>dir2/modified<RESET>
 667         <BLUE>dir2/untracked<RESET>
 668         <BLUE>untracked<RESET>
 669
 670 EOF
 671         test_config color.ui auto &&
 672         test_terminal git status | test_decode_color >output &&
 673         test_i18ncmp expect output
 674 '
 675
 676 test_expect_success TTY 'status with color.status' '
 677         test_config color.status auto &&
 678         test_terminal git status | test_decode_color >output &&
 679         test_i18ncmp expect output
 680 '
 681
 682 cat >expect <<\EOF
 683  <RED>M<RESET> dir1/modified
 684 <GREEN>A<RESET>  dir2/added
 685 <BLUE>??<RESET> dir1/untracked
 686 <BLUE>??<RESET> dir2/modified
 687 <BLUE>??<RESET> dir2/untracked
 688 <BLUE>??<RESET> untracked
 689 EOF
 690
 691 test_expect_success TTY 'status -s with color.ui' '
 692
 693         git config color.ui auto &&
 694         test_terminal git status -s | test_decode_color >output &&
 695         test_cmp expect output
 696
 697 '
 698
 699 test_expect_success TTY 'status -s with color.status' '
 700
 701         git config --unset color.ui &&
 702         git config color.status auto &&
 703         test_terminal git status -s | test_decode_color >output &&
 704         test_cmp expect output
 705
 706 '
 707
 708 cat >expect <<\EOF
 709 ## <YELLOW>master<RESET>...<CYAN>upstream<RESET> [ahead <YELLOW>1<RESET>, behind <CYAN>2<RESET>]
 710  <RED>M<RESET> dir1/modified
 711 <GREEN>A<RESET>  dir2/added
 712 <BLUE>??<RESET> dir1/untracked
 713 <BLUE>??<RESET> dir2/modified
 714 <BLUE>??<RESET> dir2/untracked
 715 <BLUE>??<RESET> untracked
 716 EOF
 717
 718 test_expect_success TTY 'status -s -b with color.status' '
 719
 720         test_terminal git status -s -b | test_decode_color >output &&
 721         test_i18ncmp expect output
 722
 723 '
 724
 725 cat >expect <<\EOF
 726  M dir1/modified
 727 A  dir2/added
 728 ?? dir1/untracked
 729 ?? dir2/modified
 730 ?? dir2/untracked
 731 ?? untracked
 732 EOF
 733
 734 test_expect_success TTY 'status --porcelain ignores color.ui' '
 735
 736         git config --unset color.status &&
 737         git config color.ui auto &&
 738         test_terminal git status --porcelain | test_decode_color >output &&
 739         test_cmp expect output
 740
 741 '
 742
 743 test_expect_success TTY 'status --porcelain ignores color.status' '
 744
 745         git config --unset color.ui &&
 746         git config color.status auto &&
 747         test_terminal git status --porcelain | test_decode_color >output &&
 748         test_cmp expect output
 749
 750 '
 751
 752 # recover unconditionally from color tests
 753 git config --unset color.status
 754 git config --unset color.ui
 755
 756 test_expect_success 'status --porcelain respects -b' '
 757
 758         git status --porcelain -b >output &&
 759         {
 760                 echo "## master...upstream [ahead 1, behind 2]" &&
 761                 cat expect
 762         } >tmp &&
 763         mv tmp expect &&
 764         test_cmp expect output
 765
 766 '
 767
 768
 769
 770 test_expect_success 'status without relative paths' '
 771         cat >expect <<\EOF &&
 772 On branch master
 773 Your branch and '\''upstream'\'' have diverged,
 774 and have 1 and 2 different commits each, respectively.
 775   (use "git pull" to merge the remote branch into yours)
 776
 777 Changes to be committed:
 778   (use "git restore --staged <file>..." to unstage)
 779         new file:   dir2/added
 780
 781 Changes not staged for commit:
 782   (use "git add <file>..." to update what will be committed)
 783   (use "git restore <file>..." to discard changes in working directory)
 784         modified:   dir1/modified
 785
 786 Untracked files:
 787   (use "git add <file>..." to include in what will be committed)
 788         dir1/untracked
 789         dir2/modified
 790         dir2/untracked
 791         untracked
 792
 793 EOF
 794         test_config status.relativePaths false &&
 795         (cd dir1 && git status) >output &&
 796         test_i18ncmp expect output
 797
 798 '
 799
 800 cat >expect <<\EOF
 801  M dir1/modified
 802 A  dir2/added
 803 ?? dir1/untracked
 804 ?? dir2/modified
 805 ?? dir2/untracked
 806 ?? untracked
 807 EOF
 808
 809 test_expect_success 'status -s without relative paths' '
 810
 811         test_config status.relativePaths false &&
 812         (cd dir1 && git status -s) >output &&
 813         test_cmp expect output
 814
 815 '
 816
 817 test_expect_success 'dry-run of partial commit excluding new file in index' '
 818         cat >expect <<EOF &&
 819 On branch master
 820 Your branch and '\''upstream'\'' have diverged,
 821 and have 1 and 2 different commits each, respectively.
 822   (use "git pull" to merge the remote branch into yours)
 823
 824 Changes to be committed:
 825   (use "git restore --staged <file>..." to unstage)
 826         modified:   dir1/modified
 827
 828 Untracked files:
 829   (use "git add <file>..." to include in what will be committed)
 830         dir1/untracked
 831         dir2/
 832         untracked
 833
 834 EOF
 835         git commit --dry-run dir1/modified >output &&
 836         test_i18ncmp expect output
 837 '
 838
 839 cat >expect <<EOF
 840 :100644 100644 $EMPTY_BLOB 0000000000000000000000000000000000000000 M   dir1/modified
 841 EOF
 842 test_expect_success 'status refreshes the index' '
 843         touch dir2/added &&
 844         git status &&
 845         git diff-files >output &&
 846         test_cmp expect output
 847 '
 848
 849 test_expect_success 'status shows detached HEAD properly after checking out non-local upstream branch' '
 850         test_when_finished rm -rf upstream downstream actual &&
 851
 852         test_create_repo upstream &&
 853         test_commit -C upstream foo &&
 854
 855         git clone upstream downstream &&
 856         git -C downstream checkout @{u} &&
 857         git -C downstream status >actual &&
 858         test_i18ngrep "HEAD detached at [0-9a-f]\\+" actual
 859 '
 860
 861 test_expect_success 'setup status submodule summary' '
 862         test_create_repo sm && (
 863                 cd sm &&
 864                 >foo &&
 865                 git add foo &&
 866                 git commit -m "Add foo"
 867         ) &&
 868         git add sm
 869 '
 870
 871 test_expect_success 'status submodule summary is disabled by default' '
 872         cat >expect <<EOF &&
 873 On branch master
 874 Your branch and '\''upstream'\'' have diverged,
 875 and have 1 and 2 different commits each, respectively.
 876   (use "git pull" to merge the remote branch into yours)
 877
 878 Changes to be committed:
 879   (use "git restore --staged <file>..." to unstage)
 880         new file:   dir2/added
 881         new file:   sm
 882
 883 Changes not staged for commit:
 884   (use "git add <file>..." to update what will be committed)
 885   (use "git restore <file>..." to discard changes in working directory)
 886         modified:   dir1/modified
 887
 888 Untracked files:
 889   (use "git add <file>..." to include in what will be committed)
 890         dir1/untracked
 891         dir2/modified
 892         dir2/untracked
 893         untracked
 894
 895 EOF
 896         git status >output &&
 897         test_i18ncmp expect output
 898 '
 899
 900 # we expect the same as the previous test
 901 test_expect_success 'status --untracked-files=all does not show submodule' '
 902         git status --untracked-files=all >output &&
 903         test_i18ncmp expect output
 904 '
 905
 906 cat >expect <<EOF
 907  M dir1/modified
 908 A  dir2/added
 909 A  sm
 910 ?? dir1/untracked
 911 ?? dir2/modified
 912 ?? dir2/untracked
 913 ?? untracked
 914 EOF
 915 test_expect_success 'status -s submodule summary is disabled by default' '
 916         git status -s >output &&
 917         test_cmp expect output
 918 '
 919
 920 # we expect the same as the previous test
 921 test_expect_success 'status -s --untracked-files=all does not show submodule' '
 922         git status -s --untracked-files=all >output &&
 923         test_cmp expect output
 924 '
 925
 926 head=$(cd sm && git rev-parse --short=7 --verify HEAD)
 927
 928 test_expect_success 'status submodule summary' '
 929         cat >expect <<EOF &&
 930 On branch master
 931 Your branch and '\''upstream'\'' have diverged,
 932 and have 1 and 2 different commits each, respectively.
 933   (use "git pull" to merge the remote branch into yours)
 934
 935 Changes to be committed:
 936   (use "git restore --staged <file>..." to unstage)
 937         new file:   dir2/added
 938         new file:   sm
 939
 940 Changes not staged for commit:
 941   (use "git add <file>..." to update what will be committed)
 942   (use "git restore <file>..." to discard changes in working directory)
 943         modified:   dir1/modified
 944
 945 Submodule changes to be committed:
 946
 947 * sm 0000000...$head (1):
 948   > Add foo
 949
 950 Untracked files:
 951   (use "git add <file>..." to include in what will be committed)
 952         dir1/untracked
 953         dir2/modified
 954         dir2/untracked
 955         untracked
 956
 957 EOF
 958         git config status.submodulesummary 10 &&
 959         git status >output &&
 960         test_i18ncmp expect output
 961 '
 962
 963 test_expect_success 'status submodule summary with status.displayCommentPrefix=false' '
 964         strip_comments expect &&
 965         git -c status.displayCommentPrefix=false status >output &&
 966         test_i18ncmp expect output
 967 '
 968
 969 test_expect_success 'commit with submodule summary ignores status.displayCommentPrefix' '
 970         commit_template_commented
 971 '
 972
 973 cat >expect <<EOF
 974  M dir1/modified
 975 A  dir2/added
 976 A  sm
 977 ?? dir1/untracked
 978 ?? dir2/modified
 979 ?? dir2/untracked
 980 ?? untracked
 981 EOF
 982 test_expect_success 'status -s submodule summary' '
 983         git status -s >output &&
 984         test_cmp expect output
 985 '
 986
 987 test_expect_success 'status submodule summary (clean submodule): commit' '
 988         cat >expect <<EOF &&
 989 On branch master
 990 Your branch and '\''upstream'\'' have diverged,
 991 and have 2 and 2 different commits each, respectively.
 992   (use "git pull" to merge the remote branch into yours)
 993
 994 Changes not staged for commit:
 995   (use "git add <file>..." to update what will be committed)
 996   (use "git restore <file>..." to discard changes in working directory)
 997         modified:   dir1/modified
 998
 999 Untracked files:
1000   (use "git add <file>..." to include in what will be committed)
1001         dir1/untracked
1002         dir2/modified
1003         dir2/untracked
1004         untracked
1005
1006 no changes added to commit (use "git add" and/or "git commit -a")
1007 EOF
1008         git commit -m "commit submodule" &&
1009         git config status.submodulesummary 10 &&
1010         test_must_fail git commit --dry-run >output &&
1011         test_i18ncmp expect output &&
1012         git status >output &&
1013         test_i18ncmp expect output
1014 '
1015
1016 cat >expect <<EOF
1017  M dir1/modified
1018 ?? dir1/untracked
1019 ?? dir2/modified
1020 ?? dir2/untracked
1021 ?? untracked
1022 EOF
1023 test_expect_success 'status -s submodule summary (clean submodule)' '
1024         git status -s >output &&
1025         test_cmp expect output
1026 '
1027
1028 test_expect_success 'status -z implies porcelain' '
1029         git status --porcelain |
1030         perl -pe "s/\012/\000/g" >expect &&
1031         git status -z >output &&
1032         test_cmp expect output
1033 '
1034
1035 test_expect_success 'commit --dry-run submodule summary (--amend)' '
1036         cat >expect <<EOF &&
1037 On branch master
1038 Your branch and '\''upstream'\'' have diverged,
1039 and have 2 and 2 different commits each, respectively.
1040   (use "git pull" to merge the remote branch into yours)
1041
1042 Changes to be committed:
1043   (use "git restore --source=HEAD^1 --staged <file>..." to unstage)
1044         new file:   dir2/added
1045         new file:   sm
1046
1047 Changes not staged for commit:
1048   (use "git add <file>..." to update what will be committed)
1049   (use "git restore <file>..." to discard changes in working directory)
1050         modified:   dir1/modified
1051
1052 Submodule changes to be committed:
1053
1054 * sm 0000000...$head (1):
1055   > Add foo
1056
1057 Untracked files:
1058   (use "git add <file>..." to include in what will be committed)
1059         dir1/untracked
1060         dir2/modified
1061         dir2/untracked
1062         untracked
1063
1064 EOF
1065         git config status.submodulesummary 10 &&
1066         git commit --dry-run --amend >output &&
1067         test_i18ncmp expect output
1068 '
1069
1070 test_expect_success POSIXPERM,SANITY 'status succeeds in a read-only repository' '
1071         test_when_finished "chmod 775 .git" &&
1072         (
1073                 chmod a-w .git &&
1074                 # make dir1/tracked stat-dirty
1075                 >dir1/tracked1 && mv -f dir1/tracked1 dir1/tracked &&
1076                 git status -s >output &&
1077                 ! grep dir1/tracked output &&
1078                 # make sure "status" succeeded without writing index out
1079                 git diff-files | grep dir1/tracked
1080         )
1081 '
1082
1083 (cd sm && echo > bar && git add bar && git commit -q -m 'Add bar') && git add sm
1084 new_head=$(cd sm && git rev-parse --short=7 --verify HEAD)
1085 touch .gitmodules
1086
1087 test_expect_success '--ignore-submodules=untracked suppresses submodules with untracked content' '
1088         cat > expect << EOF &&
1089 On branch master
1090 Your branch and '\''upstream'\'' have diverged,
1091 and have 2 and 2 different commits each, respectively.
1092   (use "git pull" to merge the remote branch into yours)
1093
1094 Changes to be committed:
1095   (use "git restore --staged <file>..." to unstage)
1096         modified:   sm
1097
1098 Changes not staged for commit:
1099   (use "git add <file>..." to update what will be committed)
1100   (use "git restore <file>..." to discard changes in working directory)
1101         modified:   dir1/modified
1102
1103 Submodule changes to be committed:
1104
1105 * sm $head...$new_head (1):
1106   > Add bar
1107
1108 Untracked files:
1109   (use "git add <file>..." to include in what will be committed)
1110         .gitmodules
1111         dir1/untracked
1112         dir2/modified
1113         dir2/untracked
1114         untracked
1115
1116 EOF
1117         echo modified  sm/untracked &&
1118         git status --ignore-submodules=untracked >output &&
1119         test_i18ncmp expect output
1120 '
1121
1122 test_expect_success '.gitmodules ignore=untracked suppresses submodules with untracked content' '
1123         test_config diff.ignoreSubmodules dirty &&
1124         git status >output &&
1125         test_i18ncmp expect output &&
1126         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1127         git config --add -f .gitmodules submodule.subname.path sm &&
1128         git status >output &&
1129         test_i18ncmp expect output &&
1130         git config -f .gitmodules  --remove-section submodule.subname
1131 '
1132
1133 test_expect_success '.git/config ignore=untracked suppresses submodules with untracked content' '
1134         git config --add -f .gitmodules submodule.subname.ignore none &&
1135         git config --add -f .gitmodules submodule.subname.path sm &&
1136         git config --add submodule.subname.ignore untracked &&
1137         git config --add submodule.subname.path sm &&
1138         git status >output &&
1139         test_i18ncmp expect output &&
1140         git config --remove-section submodule.subname &&
1141         git config --remove-section -f .gitmodules submodule.subname
1142 '
1143
1144 test_expect_success '--ignore-submodules=dirty suppresses submodules with untracked content' '
1145         git status --ignore-submodules=dirty >output &&
1146         test_i18ncmp expect output
1147 '
1148
1149 test_expect_success '.gitmodules ignore=dirty suppresses submodules with untracked content' '
1150         test_config diff.ignoreSubmodules dirty &&
1151         git status >output &&
1152         ! test -s actual &&
1153         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1154         git config --add -f .gitmodules submodule.subname.path sm &&
1155         git status >output &&
1156         test_i18ncmp expect output &&
1157         git config -f .gitmodules  --remove-section submodule.subname
1158 '
1159
1160 test_expect_success '.git/config ignore=dirty suppresses submodules with untracked content' '
1161         git config --add -f .gitmodules submodule.subname.ignore none &&
1162         git config --add -f .gitmodules submodule.subname.path sm &&
1163         git config --add submodule.subname.ignore dirty &&
1164         git config --add submodule.subname.path sm &&
1165         git status >output &&
1166         test_i18ncmp expect output &&
1167         git config --remove-section submodule.subname &&
1168         git config -f .gitmodules  --remove-section submodule.subname
1169 '
1170
1171 test_expect_success '--ignore-submodules=dirty suppresses submodules with modified content' '
1172         echo modified >sm/foo &&
1173         git status --ignore-submodules=dirty >output &&
1174         test_i18ncmp expect output
1175 '
1176
1177 test_expect_success '.gitmodules ignore=dirty suppresses submodules with modified content' '
1178         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1179         git config --add -f .gitmodules submodule.subname.path sm &&
1180         git status >output &&
1181         test_i18ncmp expect output &&
1182         git config -f .gitmodules  --remove-section submodule.subname
1183 '
1184
1185 test_expect_success '.git/config ignore=dirty suppresses submodules with modified content' '
1186         git config --add -f .gitmodules submodule.subname.ignore none &&
1187         git config --add -f .gitmodules submodule.subname.path sm &&
1188         git config --add submodule.subname.ignore dirty &&
1189         git config --add submodule.subname.path sm &&
1190         git status >output &&
1191         test_i18ncmp expect output &&
1192         git config --remove-section submodule.subname &&
1193         git config -f .gitmodules  --remove-section submodule.subname
1194 '
1195
1196 test_expect_success "--ignore-submodules=untracked doesn't suppress submodules with modified content" '
1197         cat > expect << EOF &&
1198 On branch master
1199 Your branch and '\''upstream'\'' have diverged,
1200 and have 2 and 2 different commits each, respectively.
1201   (use "git pull" to merge the remote branch into yours)
1202
1203 Changes to be committed:
1204   (use "git restore --staged <file>..." to unstage)
1205         modified:   sm
1206
1207 Changes not staged for commit:
1208   (use "git add <file>..." to update what will be committed)
1209   (use "git restore <file>..." to discard changes in working directory)
1210   (commit or discard the untracked or modified content in submodules)
1211         modified:   dir1/modified
1212         modified:   sm (modified content)
1213
1214 Submodule changes to be committed:
1215
1216 * sm $head...$new_head (1):
1217   > Add bar
1218
1219 Untracked files:
1220   (use "git add <file>..." to include in what will be committed)
1221         .gitmodules
1222         dir1/untracked
1223         dir2/modified
1224         dir2/untracked
1225         untracked
1226
1227 EOF
1228         git status --ignore-submodules=untracked > output &&
1229         test_i18ncmp expect output
1230 '
1231
1232 test_expect_success ".gitmodules ignore=untracked doesn't suppress submodules with modified content" '
1233         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1234         git config --add -f .gitmodules submodule.subname.path sm &&
1235         git status >output &&
1236         test_i18ncmp expect output &&
1237         git config -f .gitmodules  --remove-section submodule.subname
1238 '
1239
1240 test_expect_success ".git/config ignore=untracked doesn't suppress submodules with modified content" '
1241         git config --add -f .gitmodules submodule.subname.ignore none &&
1242         git config --add -f .gitmodules submodule.subname.path sm &&
1243         git config --add submodule.subname.ignore untracked &&
1244         git config --add submodule.subname.path sm &&
1245         git status >output &&
1246         test_i18ncmp expect output &&
1247         git config --remove-section submodule.subname &&
1248         git config -f .gitmodules  --remove-section submodule.subname
1249 '
1250
1251 head2=$(cd sm && git commit -q -m "2nd commit" foo && git rev-parse --short=7 --verify HEAD)
1252
1253 test_expect_success "--ignore-submodules=untracked doesn't suppress submodule summary" '
1254         cat > expect << EOF &&
1255 On branch master
1256 Your branch and '\''upstream'\'' have diverged,
1257 and have 2 and 2 different commits each, respectively.
1258   (use "git pull" to merge the remote branch into yours)
1259
1260 Changes to be committed:
1261   (use "git restore --staged <file>..." to unstage)
1262         modified:   sm
1263
1264 Changes not staged for commit:
1265   (use "git add <file>..." to update what will be committed)
1266   (use "git restore <file>..." to discard changes in working directory)
1267         modified:   dir1/modified
1268         modified:   sm (new commits)
1269
1270 Submodule changes to be committed:
1271
1272 * sm $head...$new_head (1):
1273   > Add bar
1274
1275 Submodules changed but not updated:
1276
1277 * sm $new_head...$head2 (1):
1278   > 2nd commit
1279
1280 Untracked files:
1281   (use "git add <file>..." to include in what will be committed)
1282         .gitmodules
1283         dir1/untracked
1284         dir2/modified
1285         dir2/untracked
1286         untracked
1287
1288 EOF
1289         git status --ignore-submodules=untracked > output &&
1290         test_i18ncmp expect output
1291 '
1292
1293 test_expect_success ".gitmodules ignore=untracked doesn't suppress submodule summary" '
1294         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1295         git config --add -f .gitmodules submodule.subname.path sm &&
1296         git status >output &&
1297         test_i18ncmp expect output &&
1298         git config -f .gitmodules  --remove-section submodule.subname
1299 '
1300
1301 test_expect_success ".git/config ignore=untracked doesn't suppress submodule summary" '
1302         git config --add -f .gitmodules submodule.subname.ignore none &&
1303         git config --add -f .gitmodules submodule.subname.path sm &&
1304         git config --add submodule.subname.ignore untracked &&
1305         git config --add submodule.subname.path sm &&
1306         git status >output &&
1307         test_i18ncmp expect output &&
1308         git config --remove-section submodule.subname &&
1309         git config -f .gitmodules  --remove-section submodule.subname
1310 '
1311
1312 test_expect_success "--ignore-submodules=dirty doesn't suppress submodule summary" '
1313         git status --ignore-submodules=dirty > output &&
1314         test_i18ncmp expect output
1315 '
1316 test_expect_success ".gitmodules ignore=dirty doesn't suppress submodule summary" '
1317         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1318         git config --add -f .gitmodules submodule.subname.path sm &&
1319         git status >output &&
1320         test_i18ncmp expect output &&
1321         git config -f .gitmodules  --remove-section submodule.subname
1322 '
1323
1324 test_expect_success ".git/config ignore=dirty doesn't suppress submodule summary" '
1325         git config --add -f .gitmodules submodule.subname.ignore none &&
1326         git config --add -f .gitmodules submodule.subname.path sm &&
1327         git config --add submodule.subname.ignore dirty &&
1328         git config --add submodule.subname.path sm &&
1329         git status >output &&
1330         test_i18ncmp expect output &&
1331         git config --remove-section submodule.subname &&
1332         git config -f .gitmodules  --remove-section submodule.subname
1333 '
1334
1335 cat > expect << EOF
1336 ; On branch master
1337 ; Your branch and 'upstream' have diverged,
1338 ; and have 2 and 2 different commits each, respectively.
1339 ;   (use "git pull" to merge the remote branch into yours)
1340 ;
1341 ; Changes to be committed:
1342 ;   (use "git restore --staged <file>..." to unstage)
1343 ;       modified:   sm
1344 ;
1345 ; Changes not staged for commit:
1346 ;   (use "git add <file>..." to update what will be committed)
1347 ;   (use "git restore <file>..." to discard changes in working directory)
1348 ;       modified:   dir1/modified
1349 ;       modified:   sm (new commits)
1350 ;
1351 ; Submodule changes to be committed:
1352 ;
1353 ; * sm $head...$new_head (1):
1354 ;   > Add bar
1355 ;
1356 ; Submodules changed but not updated:
1357 ;
1358 ; * sm $new_head...$head2 (1):
1359 ;   > 2nd commit
1360 ;
1361 ; Untracked files:
1362 ;   (use "git add <file>..." to include in what will be committed)
1363 ;       .gitmodules
1364 ;       dir1/untracked
1365 ;       dir2/modified
1366 ;       dir2/untracked
1367 ;       untracked
1368 ;
1369 EOF
1370
1371 test_expect_success "status (core.commentchar with submodule summary)" '
1372         test_config core.commentchar ";" &&
1373         git -c status.displayCommentPrefix=true status >output &&
1374         test_i18ncmp expect output
1375 '
1376
1377 test_expect_success "status (core.commentchar with two chars with submodule summary)" '
1378         test_config core.commentchar ";;" &&
1379         test_must_fail git -c status.displayCommentPrefix=true status
1380 '
1381
1382 test_expect_success "--ignore-submodules=all suppresses submodule summary" '
1383         cat > expect << EOF &&
1384 On branch master
1385 Your branch and '\''upstream'\'' have diverged,
1386 and have 2 and 2 different commits each, respectively.
1387   (use "git pull" to merge the remote branch into yours)
1388
1389 Changes not staged for commit:
1390   (use "git add <file>..." to update what will be committed)
1391   (use "git restore <file>..." to discard changes in working directory)
1392         modified:   dir1/modified
1393
1394 Untracked files:
1395   (use "git add <file>..." to include in what will be committed)
1396         .gitmodules
1397         dir1/untracked
1398         dir2/modified
1399         dir2/untracked
1400         untracked
1401
1402 no changes added to commit (use "git add" and/or "git commit -a")
1403 EOF
1404         git status --ignore-submodules=all > output &&
1405         test_i18ncmp expect output
1406 '
1407
1408 test_expect_success '.gitmodules ignore=all suppresses unstaged submodule summary' '
1409         cat > expect << EOF &&
1410 On branch master
1411 Your branch and '\''upstream'\'' have diverged,
1412 and have 2 and 2 different commits each, respectively.
1413   (use "git pull" to merge the remote branch into yours)
1414
1415 Changes to be committed:
1416   (use "git restore --staged <file>..." to unstage)
1417         modified:   sm
1418
1419 Changes not staged for commit:
1420   (use "git add <file>..." to update what will be committed)
1421   (use "git restore <file>..." to discard changes in working directory)
1422         modified:   dir1/modified
1423
1424 Untracked files:
1425   (use "git add <file>..." to include in what will be committed)
1426         .gitmodules
1427         dir1/untracked
1428         dir2/modified
1429         dir2/untracked
1430         untracked
1431
1432 EOF
1433         git config --add -f .gitmodules submodule.subname.ignore all &&
1434         git config --add -f .gitmodules submodule.subname.path sm &&
1435         git status > output &&
1436         test_i18ncmp expect output &&
1437         git config -f .gitmodules  --remove-section submodule.subname
1438 '
1439
1440 test_expect_success '.git/config ignore=all suppresses unstaged submodule summary' '
1441         git config --add -f .gitmodules submodule.subname.ignore none &&
1442         git config --add -f .gitmodules submodule.subname.path sm &&
1443         git config --add submodule.subname.ignore all &&
1444         git config --add submodule.subname.path sm &&
1445         git status > output &&
1446         test_i18ncmp expect output &&
1447         git config --remove-section submodule.subname &&
1448         git config -f .gitmodules  --remove-section submodule.subname
1449 '
1450
1451 test_expect_success 'setup of test environment' '
1452         git config status.showUntrackedFiles no &&
1453         git status -s >expected_short &&
1454         git status --no-short >expected_noshort
1455 '
1456
1457 test_expect_success '"status.short=true" same as "-s"' '
1458         git -c status.short=true status >actual &&
1459         test_cmp expected_short actual
1460 '
1461
1462 test_expect_success '"status.short=true" weaker than "--no-short"' '
1463         git -c status.short=true status --no-short >actual &&
1464         test_cmp expected_noshort actual
1465 '
1466
1467 test_expect_success '"status.short=false" same as "--no-short"' '
1468         git -c status.short=false status >actual &&
1469         test_cmp expected_noshort actual
1470 '
1471
1472 test_expect_success '"status.short=false" weaker than "-s"' '
1473         git -c status.short=false status -s >actual &&
1474         test_cmp expected_short actual
1475 '
1476
1477 test_expect_success '"status.branch=true" same as "-b"' '
1478         git status -sb >expected_branch &&
1479         git -c status.branch=true status -s >actual &&
1480         test_cmp expected_branch actual
1481 '
1482
1483 test_expect_success '"status.branch=true" different from "--no-branch"' '
1484         git status -s --no-branch  >expected_nobranch &&
1485         git -c status.branch=true status -s >actual &&
1486         ! test_cmp expected_nobranch actual
1487 '
1488
1489 test_expect_success '"status.branch=true" weaker than "--no-branch"' '
1490         git -c status.branch=true status -s --no-branch >actual &&
1491         test_cmp expected_nobranch actual
1492 '
1493
1494 test_expect_success '"status.branch=true" weaker than "--porcelain"' '
1495        git -c status.branch=true status --porcelain >actual &&
1496        test_cmp expected_nobranch actual
1497 '
1498
1499 test_expect_success '"status.branch=false" same as "--no-branch"' '
1500         git -c status.branch=false status -s >actual &&
1501         test_cmp expected_nobranch actual
1502 '
1503
1504 test_expect_success '"status.branch=false" weaker than "-b"' '
1505         git -c status.branch=false status -sb >actual &&
1506         test_cmp expected_branch actual
1507 '
1508
1509 test_expect_success 'Restore default test environment' '
1510         git config --unset status.showUntrackedFiles
1511 '
1512
1513 test_expect_success 'git commit will commit a staged but ignored submodule' '
1514         git config --add -f .gitmodules submodule.subname.ignore all &&
1515         git config --add -f .gitmodules submodule.subname.path sm &&
1516         git config --add submodule.subname.ignore all &&
1517         git status -s --ignore-submodules=dirty >output &&
1518         test_i18ngrep "^M. sm" output &&
1519         GIT_EDITOR="echo hello >>\"\$1\"" &&
1520         export GIT_EDITOR &&
1521         git commit -uno &&
1522         git status -s --ignore-submodules=dirty >output &&
1523         test_i18ngrep ! "^M. sm" output
1524 '
1525
1526 test_expect_success 'git commit --dry-run will show a staged but ignored submodule' '
1527         git reset HEAD^ &&
1528         git add sm &&
1529         cat >expect << EOF &&
1530 On branch master
1531 Your branch and '\''upstream'\'' have diverged,
1532 and have 2 and 2 different commits each, respectively.
1533   (use "git pull" to merge the remote branch into yours)
1534
1535 Changes to be committed:
1536   (use "git restore --staged <file>..." to unstage)
1537         modified:   sm
1538
1539 Changes not staged for commit:
1540   (use "git add <file>..." to update what will be committed)
1541   (use "git restore <file>..." to discard changes in working directory)
1542         modified:   dir1/modified
1543
1544 Untracked files not listed (use -u option to show untracked files)
1545 EOF
1546         git commit -uno --dry-run >output &&
1547         test_i18ncmp expect output &&
1548         git status -s --ignore-submodules=dirty >output &&
1549         test_i18ngrep "^M. sm" output
1550 '
1551
1552 test_expect_success 'git commit -m will commit a staged but ignored submodule' '
1553         git commit -uno -m message &&
1554         git status -s --ignore-submodules=dirty >output &&
1555         test_i18ngrep ! "^M. sm" output &&
1556         git config --remove-section submodule.subname &&
1557         git config -f .gitmodules  --remove-section submodule.subname
1558 '
1559
1560 test_expect_success 'show stash info with "--show-stash"' '
1561         git reset --hard &&
1562         git stash clear &&
1563         echo 1 >file &&
1564         git add file &&
1565         git stash &&
1566         git status >expected_default &&
1567         git status --show-stash >expected_with_stash &&
1568         test_i18ngrep "^Your stash currently has 1 entry$" expected_with_stash
1569 '
1570
1571 test_expect_success 'no stash info with "--show-stash --no-show-stash"' '
1572         git status --show-stash --no-show-stash >expected_without_stash &&
1573         test_cmp expected_default expected_without_stash
1574 '
1575
1576 test_expect_success '"status.showStash=false" weaker than "--show-stash"' '
1577         git -c status.showStash=false status --show-stash >actual &&
1578         test_cmp expected_with_stash actual
1579 '
1580
1581 test_expect_success '"status.showStash=true" weaker than "--no-show-stash"' '
1582         git -c status.showStash=true status --no-show-stash >actual &&
1583         test_cmp expected_without_stash actual
1584 '
1585
1586 test_expect_success 'no additional info if no stash entries' '
1587         git stash clear &&
1588         git -c status.showStash=true status >actual &&
1589         test_cmp expected_without_stash actual
1590 '
1591
1592 test_expect_success '"No commits yet" should be noted in status output' '
1593         git checkout --orphan empty-branch-1 &&
1594         git status >output &&
1595         test_i18ngrep "No commits yet" output
1596 '
1597
1598 test_expect_success '"No commits yet" should not be noted in status output' '
1599         git checkout --orphan empty-branch-2 &&
1600         test_commit test-commit-1 &&
1601         git status >output &&
1602         test_i18ngrep ! "No commits yet" output
1603 '
1604
1605 test_expect_success '"Initial commit" should be noted in commit template' '
1606         git checkout --orphan empty-branch-3 &&
1607         touch to_be_committed_1 &&
1608         git add to_be_committed_1 &&
1609         git commit --dry-run >output &&
1610         test_i18ngrep "Initial commit" output
1611 '
1612
1613 test_expect_success '"Initial commit" should not be noted in commit template' '
1614         git checkout --orphan empty-branch-4 &&
1615         test_commit test-commit-2 &&
1616         touch to_be_committed_2 &&
1617         git add to_be_committed_2 &&
1618         git commit --dry-run >output &&
1619         test_i18ngrep ! "Initial commit" output
1620 '
1621
1622 test_expect_success '--no-optional-locks prevents index update' '
1623         test-tool chmtime =1234567890 .git/index &&
1624         git --no-optional-locks status &&
1625         test-tool chmtime --get .git/index >out &&
1626         grep ^1234567890 out &&
1627         git status &&
1628         test-tool chmtime --get .git/index >out &&
1629         ! grep ^1234567890 out
1630 '
1631
1632 test_done