git.oblomov.eu Git - git/blob - 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 $ZERO_OID 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 'setup status submodule summary' '
 850         test_create_repo sm && (
 851                 cd sm &&
 852                 >foo &&
 853                 git add foo &&
 854                 git commit -m "Add foo"
 855         ) &&
 856         git add sm
 857 '
 858
 859 test_expect_success 'status submodule summary is disabled by default' '
 860         cat >expect <<EOF &&
 861 On branch master
 862 Your branch and '\''upstream'\'' have diverged,
 863 and have 1 and 2 different commits each, respectively.
 864   (use "git pull" to merge the remote branch into yours)
 865
 866 Changes to be committed:
 867   (use "git restore --staged <file>..." to unstage)
 868         new file:   dir2/added
 869         new file:   sm
 870
 871 Changes not staged for commit:
 872   (use "git add <file>..." to update what will be committed)
 873   (use "git restore <file>..." to discard changes in working directory)
 874         modified:   dir1/modified
 875
 876 Untracked files:
 877   (use "git add <file>..." to include in what will be committed)
 878         dir1/untracked
 879         dir2/modified
 880         dir2/untracked
 881         untracked
 882
 883 EOF
 884         git status >output &&
 885         test_i18ncmp expect output
 886 '
 887
 888 # we expect the same as the previous test
 889 test_expect_success 'status --untracked-files=all does not show submodule' '
 890         git status --untracked-files=all >output &&
 891         test_i18ncmp expect output
 892 '
 893
 894 cat >expect <<EOF
 895  M dir1/modified
 896 A  dir2/added
 897 A  sm
 898 ?? dir1/untracked
 899 ?? dir2/modified
 900 ?? dir2/untracked
 901 ?? untracked
 902 EOF
 903 test_expect_success 'status -s submodule summary is disabled by default' '
 904         git status -s >output &&
 905         test_cmp expect output
 906 '
 907
 908 # we expect the same as the previous test
 909 test_expect_success 'status -s --untracked-files=all does not show submodule' '
 910         git status -s --untracked-files=all >output &&
 911         test_cmp expect output
 912 '
 913
 914 head=$(cd sm && git rev-parse --short=7 --verify HEAD)
 915
 916 test_expect_success 'status submodule summary' '
 917         cat >expect <<EOF &&
 918 On branch master
 919 Your branch and '\''upstream'\'' have diverged,
 920 and have 1 and 2 different commits each, respectively.
 921   (use "git pull" to merge the remote branch into yours)
 922
 923 Changes to be committed:
 924   (use "git restore --staged <file>..." to unstage)
 925         new file:   dir2/added
 926         new file:   sm
 927
 928 Changes not staged for commit:
 929   (use "git add <file>..." to update what will be committed)
 930   (use "git restore <file>..." to discard changes in working directory)
 931         modified:   dir1/modified
 932
 933 Submodule changes to be committed:
 934
 935 * sm 0000000...$head (1):
 936   > Add foo
 937
 938 Untracked files:
 939   (use "git add <file>..." to include in what will be committed)
 940         dir1/untracked
 941         dir2/modified
 942         dir2/untracked
 943         untracked
 944
 945 EOF
 946         git config status.submodulesummary 10 &&
 947         git status >output &&
 948         test_i18ncmp expect output
 949 '
 950
 951 test_expect_success 'status submodule summary with status.displayCommentPrefix=false' '
 952         strip_comments expect &&
 953         git -c status.displayCommentPrefix=false status >output &&
 954         test_i18ncmp expect output
 955 '
 956
 957 test_expect_success 'commit with submodule summary ignores status.displayCommentPrefix' '
 958         commit_template_commented
 959 '
 960
 961 cat >expect <<EOF
 962  M dir1/modified
 963 A  dir2/added
 964 A  sm
 965 ?? dir1/untracked
 966 ?? dir2/modified
 967 ?? dir2/untracked
 968 ?? untracked
 969 EOF
 970 test_expect_success 'status -s submodule summary' '
 971         git status -s >output &&
 972         test_cmp expect output
 973 '
 974
 975 test_expect_success 'status submodule summary (clean submodule): commit' '
 976         cat >expect <<EOF &&
 977 On branch master
 978 Your branch and '\''upstream'\'' have diverged,
 979 and have 2 and 2 different commits each, respectively.
 980   (use "git pull" to merge the remote branch into yours)
 981
 982 Changes not staged for commit:
 983   (use "git add <file>..." to update what will be committed)
 984   (use "git restore <file>..." to discard changes in working directory)
 985         modified:   dir1/modified
 986
 987 Untracked files:
 988   (use "git add <file>..." to include in what will be committed)
 989         dir1/untracked
 990         dir2/modified
 991         dir2/untracked
 992         untracked
 993
 994 no changes added to commit (use "git add" and/or "git commit -a")
 995 EOF
 996         git commit -m "commit submodule" &&
 997         git config status.submodulesummary 10 &&
 998         test_must_fail git commit --dry-run >output &&
 999         test_i18ncmp expect output &&
1000         git status >output &&
1001         test_i18ncmp expect output
1002 '
1003
1004 cat >expect <<EOF
1005  M dir1/modified
1006 ?? dir1/untracked
1007 ?? dir2/modified
1008 ?? dir2/untracked
1009 ?? untracked
1010 EOF
1011 test_expect_success 'status -s submodule summary (clean submodule)' '
1012         git status -s >output &&
1013         test_cmp expect output
1014 '
1015
1016 test_expect_success 'status -z implies porcelain' '
1017         git status --porcelain |
1018         perl -pe "s/\012/\000/g" >expect &&
1019         git status -z >output &&
1020         test_cmp expect output
1021 '
1022
1023 test_expect_success 'commit --dry-run submodule summary (--amend)' '
1024         cat >expect <<EOF &&
1025 On branch master
1026 Your branch and '\''upstream'\'' have diverged,
1027 and have 2 and 2 different commits each, respectively.
1028   (use "git pull" to merge the remote branch into yours)
1029
1030 Changes to be committed:
1031   (use "git restore --source=HEAD^1 --staged <file>..." to unstage)
1032         new file:   dir2/added
1033         new file:   sm
1034
1035 Changes not staged for commit:
1036   (use "git add <file>..." to update what will be committed)
1037   (use "git restore <file>..." to discard changes in working directory)
1038         modified:   dir1/modified
1039
1040 Submodule changes to be committed:
1041
1042 * sm 0000000...$head (1):
1043   > Add foo
1044
1045 Untracked files:
1046   (use "git add <file>..." to include in what will be committed)
1047         dir1/untracked
1048         dir2/modified
1049         dir2/untracked
1050         untracked
1051
1052 EOF
1053         git config status.submodulesummary 10 &&
1054         git commit --dry-run --amend >output &&
1055         test_i18ncmp expect output
1056 '
1057
1058 test_expect_success POSIXPERM,SANITY 'status succeeds in a read-only repository' '
1059         test_when_finished "chmod 775 .git" &&
1060         (
1061                 chmod a-w .git &&
1062                 # make dir1/tracked stat-dirty
1063                 >dir1/tracked1 && mv -f dir1/tracked1 dir1/tracked &&
1064                 git status -s >output &&
1065                 ! grep dir1/tracked output &&
1066                 # make sure "status" succeeded without writing index out
1067                 git diff-files | grep dir1/tracked
1068         )
1069 '
1070
1071 (cd sm && echo > bar && git add bar && git commit -q -m 'Add bar') && git add sm
1072 new_head=$(cd sm && git rev-parse --short=7 --verify HEAD)
1073 touch .gitmodules
1074
1075 test_expect_success '--ignore-submodules=untracked suppresses submodules with untracked content' '
1076         cat > expect << EOF &&
1077 On branch master
1078 Your branch and '\''upstream'\'' have diverged,
1079 and have 2 and 2 different commits each, respectively.
1080   (use "git pull" to merge the remote branch into yours)
1081
1082 Changes to be committed:
1083   (use "git restore --staged <file>..." to unstage)
1084         modified:   sm
1085
1086 Changes not staged for commit:
1087   (use "git add <file>..." to update what will be committed)
1088   (use "git restore <file>..." to discard changes in working directory)
1089         modified:   dir1/modified
1090
1091 Submodule changes to be committed:
1092
1093 * sm $head...$new_head (1):
1094   > Add bar
1095
1096 Untracked files:
1097   (use "git add <file>..." to include in what will be committed)
1098         .gitmodules
1099         dir1/untracked
1100         dir2/modified
1101         dir2/untracked
1102         untracked
1103
1104 EOF
1105         echo modified  sm/untracked &&
1106         git status --ignore-submodules=untracked >output &&
1107         test_i18ncmp expect output
1108 '
1109
1110 test_expect_success '.gitmodules ignore=untracked suppresses submodules with untracked content' '
1111         test_config diff.ignoreSubmodules dirty &&
1112         git status >output &&
1113         test_i18ncmp expect output &&
1114         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1115         git config --add -f .gitmodules submodule.subname.path sm &&
1116         git status >output &&
1117         test_i18ncmp expect output &&
1118         git config -f .gitmodules  --remove-section submodule.subname
1119 '
1120
1121 test_expect_success '.git/config ignore=untracked suppresses submodules with untracked content' '
1122         git config --add -f .gitmodules submodule.subname.ignore none &&
1123         git config --add -f .gitmodules submodule.subname.path sm &&
1124         git config --add submodule.subname.ignore untracked &&
1125         git config --add submodule.subname.path sm &&
1126         git status >output &&
1127         test_i18ncmp expect output &&
1128         git config --remove-section submodule.subname &&
1129         git config --remove-section -f .gitmodules submodule.subname
1130 '
1131
1132 test_expect_success '--ignore-submodules=dirty suppresses submodules with untracked content' '
1133         git status --ignore-submodules=dirty >output &&
1134         test_i18ncmp expect output
1135 '
1136
1137 test_expect_success '.gitmodules ignore=dirty suppresses submodules with untracked content' '
1138         test_config diff.ignoreSubmodules dirty &&
1139         git status >output &&
1140         ! test -s actual &&
1141         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1142         git config --add -f .gitmodules submodule.subname.path sm &&
1143         git status >output &&
1144         test_i18ncmp expect output &&
1145         git config -f .gitmodules  --remove-section submodule.subname
1146 '
1147
1148 test_expect_success '.git/config ignore=dirty suppresses submodules with untracked content' '
1149         git config --add -f .gitmodules submodule.subname.ignore none &&
1150         git config --add -f .gitmodules submodule.subname.path sm &&
1151         git config --add submodule.subname.ignore dirty &&
1152         git config --add submodule.subname.path sm &&
1153         git status >output &&
1154         test_i18ncmp expect output &&
1155         git config --remove-section submodule.subname &&
1156         git config -f .gitmodules  --remove-section submodule.subname
1157 '
1158
1159 test_expect_success '--ignore-submodules=dirty suppresses submodules with modified content' '
1160         echo modified >sm/foo &&
1161         git status --ignore-submodules=dirty >output &&
1162         test_i18ncmp expect output
1163 '
1164
1165 test_expect_success '.gitmodules ignore=dirty suppresses submodules with modified content' '
1166         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1167         git config --add -f .gitmodules submodule.subname.path sm &&
1168         git status >output &&
1169         test_i18ncmp expect output &&
1170         git config -f .gitmodules  --remove-section submodule.subname
1171 '
1172
1173 test_expect_success '.git/config ignore=dirty suppresses submodules with modified content' '
1174         git config --add -f .gitmodules submodule.subname.ignore none &&
1175         git config --add -f .gitmodules submodule.subname.path sm &&
1176         git config --add submodule.subname.ignore dirty &&
1177         git config --add submodule.subname.path sm &&
1178         git status >output &&
1179         test_i18ncmp expect output &&
1180         git config --remove-section submodule.subname &&
1181         git config -f .gitmodules  --remove-section submodule.subname
1182 '
1183
1184 test_expect_success "--ignore-submodules=untracked doesn't suppress submodules with modified content" '
1185         cat > expect << EOF &&
1186 On branch master
1187 Your branch and '\''upstream'\'' have diverged,
1188 and have 2 and 2 different commits each, respectively.
1189   (use "git pull" to merge the remote branch into yours)
1190
1191 Changes to be committed:
1192   (use "git restore --staged <file>..." to unstage)
1193         modified:   sm
1194
1195 Changes not staged for commit:
1196   (use "git add <file>..." to update what will be committed)
1197   (use "git restore <file>..." to discard changes in working directory)
1198   (commit or discard the untracked or modified content in submodules)
1199         modified:   dir1/modified
1200         modified:   sm (modified content)
1201
1202 Submodule changes to be committed:
1203
1204 * sm $head...$new_head (1):
1205   > Add bar
1206
1207 Untracked files:
1208   (use "git add <file>..." to include in what will be committed)
1209         .gitmodules
1210         dir1/untracked
1211         dir2/modified
1212         dir2/untracked
1213         untracked
1214
1215 EOF
1216         git status --ignore-submodules=untracked > output &&
1217         test_i18ncmp expect output
1218 '
1219
1220 test_expect_success ".gitmodules ignore=untracked doesn't suppress submodules with modified content" '
1221         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1222         git config --add -f .gitmodules submodule.subname.path sm &&
1223         git status >output &&
1224         test_i18ncmp expect output &&
1225         git config -f .gitmodules  --remove-section submodule.subname
1226 '
1227
1228 test_expect_success ".git/config ignore=untracked doesn't suppress submodules with modified content" '
1229         git config --add -f .gitmodules submodule.subname.ignore none &&
1230         git config --add -f .gitmodules submodule.subname.path sm &&
1231         git config --add submodule.subname.ignore untracked &&
1232         git config --add submodule.subname.path sm &&
1233         git status >output &&
1234         test_i18ncmp expect output &&
1235         git config --remove-section submodule.subname &&
1236         git config -f .gitmodules  --remove-section submodule.subname
1237 '
1238
1239 head2=$(cd sm && git commit -q -m "2nd commit" foo && git rev-parse --short=7 --verify HEAD)
1240
1241 test_expect_success "--ignore-submodules=untracked doesn't suppress submodule summary" '
1242         cat > expect << EOF &&
1243 On branch master
1244 Your branch and '\''upstream'\'' have diverged,
1245 and have 2 and 2 different commits each, respectively.
1246   (use "git pull" to merge the remote branch into yours)
1247
1248 Changes to be committed:
1249   (use "git restore --staged <file>..." to unstage)
1250         modified:   sm
1251
1252 Changes not staged for commit:
1253   (use "git add <file>..." to update what will be committed)
1254   (use "git restore <file>..." to discard changes in working directory)
1255         modified:   dir1/modified
1256         modified:   sm (new commits)
1257
1258 Submodule changes to be committed:
1259
1260 * sm $head...$new_head (1):
1261   > Add bar
1262
1263 Submodules changed but not updated:
1264
1265 * sm $new_head...$head2 (1):
1266   > 2nd commit
1267
1268 Untracked files:
1269   (use "git add <file>..." to include in what will be committed)
1270         .gitmodules
1271         dir1/untracked
1272         dir2/modified
1273         dir2/untracked
1274         untracked
1275
1276 EOF
1277         git status --ignore-submodules=untracked > output &&
1278         test_i18ncmp expect output
1279 '
1280
1281 test_expect_success ".gitmodules ignore=untracked doesn't suppress submodule summary" '
1282         git config --add -f .gitmodules submodule.subname.ignore untracked &&
1283         git config --add -f .gitmodules submodule.subname.path sm &&
1284         git status >output &&
1285         test_i18ncmp expect output &&
1286         git config -f .gitmodules  --remove-section submodule.subname
1287 '
1288
1289 test_expect_success ".git/config ignore=untracked doesn't suppress submodule summary" '
1290         git config --add -f .gitmodules submodule.subname.ignore none &&
1291         git config --add -f .gitmodules submodule.subname.path sm &&
1292         git config --add submodule.subname.ignore untracked &&
1293         git config --add submodule.subname.path sm &&
1294         git status >output &&
1295         test_i18ncmp expect output &&
1296         git config --remove-section submodule.subname &&
1297         git config -f .gitmodules  --remove-section submodule.subname
1298 '
1299
1300 test_expect_success "--ignore-submodules=dirty doesn't suppress submodule summary" '
1301         git status --ignore-submodules=dirty > output &&
1302         test_i18ncmp expect output
1303 '
1304 test_expect_success ".gitmodules ignore=dirty doesn't suppress submodule summary" '
1305         git config --add -f .gitmodules submodule.subname.ignore dirty &&
1306         git config --add -f .gitmodules submodule.subname.path sm &&
1307         git status >output &&
1308         test_i18ncmp expect output &&
1309         git config -f .gitmodules  --remove-section submodule.subname
1310 '
1311
1312 test_expect_success ".git/config ignore=dirty doesn't suppress submodule summary" '
1313         git config --add -f .gitmodules submodule.subname.ignore none &&
1314         git config --add -f .gitmodules submodule.subname.path sm &&
1315         git config --add submodule.subname.ignore dirty &&
1316         git config --add submodule.subname.path sm &&
1317         git status >output &&
1318         test_i18ncmp expect output &&
1319         git config --remove-section submodule.subname &&
1320         git config -f .gitmodules  --remove-section submodule.subname
1321 '
1322
1323 cat > expect << EOF
1324 ; On branch master
1325 ; Your branch and 'upstream' have diverged,
1326 ; and have 2 and 2 different commits each, respectively.
1327 ;   (use "git pull" to merge the remote branch into yours)
1328 ;
1329 ; Changes to be committed:
1330 ;   (use "git restore --staged <file>..." to unstage)
1331 ;       modified:   sm
1332 ;
1333 ; Changes not staged for commit:
1334 ;   (use "git add <file>..." to update what will be committed)
1335 ;   (use "git restore <file>..." to discard changes in working directory)
1336 ;       modified:   dir1/modified
1337 ;       modified:   sm (new commits)
1338 ;
1339 ; Submodule changes to be committed:
1340 ;
1341 ; * sm $head...$new_head (1):
1342 ;   > Add bar
1343 ;
1344 ; Submodules changed but not updated:
1345 ;
1346 ; * sm $new_head...$head2 (1):
1347 ;   > 2nd commit
1348 ;
1349 ; Untracked files:
1350 ;   (use "git add <file>..." to include in what will be committed)
1351 ;       .gitmodules
1352 ;       dir1/untracked
1353 ;       dir2/modified
1354 ;       dir2/untracked
1355 ;       untracked
1356 ;
1357 EOF
1358
1359 test_expect_success "status (core.commentchar with submodule summary)" '
1360         test_config core.commentchar ";" &&
1361         git -c status.displayCommentPrefix=true status >output &&
1362         test_i18ncmp expect output
1363 '
1364
1365 test_expect_success "status (core.commentchar with two chars with submodule summary)" '
1366         test_config core.commentchar ";;" &&
1367         test_must_fail git -c status.displayCommentPrefix=true status
1368 '
1369
1370 test_expect_success "--ignore-submodules=all suppresses submodule summary" '
1371         cat > expect << EOF &&
1372 On branch master
1373 Your branch and '\''upstream'\'' have diverged,
1374 and have 2 and 2 different commits each, respectively.
1375   (use "git pull" to merge the remote branch into yours)
1376
1377 Changes not staged for commit:
1378   (use "git add <file>..." to update what will be committed)
1379   (use "git restore <file>..." to discard changes in working directory)
1380         modified:   dir1/modified
1381
1382 Untracked files:
1383   (use "git add <file>..." to include in what will be committed)
1384         .gitmodules
1385         dir1/untracked
1386         dir2/modified
1387         dir2/untracked
1388         untracked
1389
1390 no changes added to commit (use "git add" and/or "git commit -a")
1391 EOF
1392         git status --ignore-submodules=all > output &&
1393         test_i18ncmp expect output
1394 '
1395
1396 test_expect_success '.gitmodules ignore=all suppresses unstaged submodule summary' '
1397         cat > expect << EOF &&
1398 On branch master
1399 Your branch and '\''upstream'\'' have diverged,
1400 and have 2 and 2 different commits each, respectively.
1401   (use "git pull" to merge the remote branch into yours)
1402
1403 Changes to be committed:
1404   (use "git restore --staged <file>..." to unstage)
1405         modified:   sm
1406
1407 Changes not staged for commit:
1408   (use "git add <file>..." to update what will be committed)
1409   (use "git restore <file>..." to discard changes in working directory)
1410         modified:   dir1/modified
1411
1412 Untracked files:
1413   (use "git add <file>..." to include in what will be committed)
1414         .gitmodules
1415         dir1/untracked
1416         dir2/modified
1417         dir2/untracked
1418         untracked
1419
1420 EOF
1421         git config --add -f .gitmodules submodule.subname.ignore all &&
1422         git config --add -f .gitmodules submodule.subname.path sm &&
1423         git status > output &&
1424         test_i18ncmp expect output &&
1425         git config -f .gitmodules  --remove-section submodule.subname
1426 '
1427
1428 test_expect_success '.git/config ignore=all suppresses unstaged submodule summary' '
1429         git config --add -f .gitmodules submodule.subname.ignore none &&
1430         git config --add -f .gitmodules submodule.subname.path sm &&
1431         git config --add submodule.subname.ignore all &&
1432         git config --add submodule.subname.path sm &&
1433         git status > output &&
1434         test_i18ncmp expect output &&
1435         git config --remove-section submodule.subname &&
1436         git config -f .gitmodules  --remove-section submodule.subname
1437 '
1438
1439 test_expect_success 'setup of test environment' '
1440         git config status.showUntrackedFiles no &&
1441         git status -s >expected_short &&
1442         git status --no-short >expected_noshort
1443 '
1444
1445 test_expect_success '"status.short=true" same as "-s"' '
1446         git -c status.short=true status >actual &&
1447         test_cmp expected_short actual
1448 '
1449
1450 test_expect_success '"status.short=true" weaker than "--no-short"' '
1451         git -c status.short=true status --no-short >actual &&
1452         test_cmp expected_noshort actual
1453 '
1454
1455 test_expect_success '"status.short=false" same as "--no-short"' '
1456         git -c status.short=false status >actual &&
1457         test_cmp expected_noshort actual
1458 '
1459
1460 test_expect_success '"status.short=false" weaker than "-s"' '
1461         git -c status.short=false status -s >actual &&
1462         test_cmp expected_short actual
1463 '
1464
1465 test_expect_success '"status.branch=true" same as "-b"' '
1466         git status -sb >expected_branch &&
1467         git -c status.branch=true status -s >actual &&
1468         test_cmp expected_branch actual
1469 '
1470
1471 test_expect_success '"status.branch=true" different from "--no-branch"' '
1472         git status -s --no-branch  >expected_nobranch &&
1473         git -c status.branch=true status -s >actual &&
1474         ! test_cmp expected_nobranch actual
1475 '
1476
1477 test_expect_success '"status.branch=true" weaker than "--no-branch"' '
1478         git -c status.branch=true status -s --no-branch >actual &&
1479         test_cmp expected_nobranch actual
1480 '
1481
1482 test_expect_success '"status.branch=true" weaker than "--porcelain"' '
1483        git -c status.branch=true status --porcelain >actual &&
1484        test_cmp expected_nobranch actual
1485 '
1486
1487 test_expect_success '"status.branch=false" same as "--no-branch"' '
1488         git -c status.branch=false status -s >actual &&
1489         test_cmp expected_nobranch actual
1490 '
1491
1492 test_expect_success '"status.branch=false" weaker than "-b"' '
1493         git -c status.branch=false status -sb >actual &&
1494         test_cmp expected_branch actual
1495 '
1496
1497 test_expect_success 'Restore default test environment' '
1498         git config --unset status.showUntrackedFiles
1499 '
1500
1501 test_expect_success 'git commit will commit a staged but ignored submodule' '
1502         git config --add -f .gitmodules submodule.subname.ignore all &&
1503         git config --add -f .gitmodules submodule.subname.path sm &&
1504         git config --add submodule.subname.ignore all &&
1505         git status -s --ignore-submodules=dirty >output &&
1506         test_i18ngrep "^M. sm" output &&
1507         GIT_EDITOR="echo hello >>\"\$1\"" &&
1508         export GIT_EDITOR &&
1509         git commit -uno &&
1510         git status -s --ignore-submodules=dirty >output &&
1511         test_i18ngrep ! "^M. sm" output
1512 '
1513
1514 test_expect_success 'git commit --dry-run will show a staged but ignored submodule' '
1515         git reset HEAD^ &&
1516         git add sm &&
1517         cat >expect << EOF &&
1518 On branch master
1519 Your branch and '\''upstream'\'' have diverged,
1520 and have 2 and 2 different commits each, respectively.
1521   (use "git pull" to merge the remote branch into yours)
1522
1523 Changes to be committed:
1524   (use "git restore --staged <file>..." to unstage)
1525         modified:   sm
1526
1527 Changes not staged for commit:
1528   (use "git add <file>..." to update what will be committed)
1529   (use "git restore <file>..." to discard changes in working directory)
1530         modified:   dir1/modified
1531
1532 Untracked files not listed (use -u option to show untracked files)
1533 EOF
1534         git commit -uno --dry-run >output &&
1535         test_i18ncmp expect output &&
1536         git status -s --ignore-submodules=dirty >output &&
1537         test_i18ngrep "^M. sm" output
1538 '
1539
1540 test_expect_success 'git commit -m will commit a staged but ignored submodule' '
1541         git commit -uno -m message &&
1542         git status -s --ignore-submodules=dirty >output &&
1543         test_i18ngrep ! "^M. sm" output &&
1544         git config --remove-section submodule.subname &&
1545         git config -f .gitmodules  --remove-section submodule.subname
1546 '
1547
1548 test_expect_success 'show stash info with "--show-stash"' '
1549         git reset --hard &&
1550         git stash clear &&
1551         echo 1 >file &&
1552         git add file &&
1553         git stash &&
1554         git status >expected_default &&
1555         git status --show-stash >expected_with_stash &&
1556         test_i18ngrep "^Your stash currently has 1 entry$" expected_with_stash
1557 '
1558
1559 test_expect_success 'no stash info with "--show-stash --no-show-stash"' '
1560         git status --show-stash --no-show-stash >expected_without_stash &&
1561         test_cmp expected_default expected_without_stash
1562 '
1563
1564 test_expect_success '"status.showStash=false" weaker than "--show-stash"' '
1565         git -c status.showStash=false status --show-stash >actual &&
1566         test_cmp expected_with_stash actual
1567 '
1568
1569 test_expect_success '"status.showStash=true" weaker than "--no-show-stash"' '
1570         git -c status.showStash=true status --no-show-stash >actual &&
1571         test_cmp expected_without_stash actual
1572 '
1573
1574 test_expect_success 'no additional info if no stash entries' '
1575         git stash clear &&
1576         git -c status.showStash=true status >actual &&
1577         test_cmp expected_without_stash actual
1578 '
1579
1580 test_expect_success '"No commits yet" should be noted in status output' '
1581         git checkout --orphan empty-branch-1 &&
1582         git status >output &&
1583         test_i18ngrep "No commits yet" output
1584 '
1585
1586 test_expect_success '"No commits yet" should not be noted in status output' '
1587         git checkout --orphan empty-branch-2 &&
1588         test_commit test-commit-1 &&
1589         git status >output &&
1590         test_i18ngrep ! "No commits yet" output
1591 '
1592
1593 test_expect_success '"Initial commit" should be noted in commit template' '
1594         git checkout --orphan empty-branch-3 &&
1595         touch to_be_committed_1 &&
1596         git add to_be_committed_1 &&
1597         git commit --dry-run >output &&
1598         test_i18ngrep "Initial commit" output
1599 '
1600
1601 test_expect_success '"Initial commit" should not be noted in commit template' '
1602         git checkout --orphan empty-branch-4 &&
1603         test_commit test-commit-2 &&
1604         touch to_be_committed_2 &&
1605         git add to_be_committed_2 &&
1606         git commit --dry-run >output &&
1607         test_i18ngrep ! "Initial commit" output
1608 '
1609
1610 test_expect_success '--no-optional-locks prevents index update' '
1611         test-tool chmtime =1234567890 .git/index &&
1612         git --no-optional-locks status &&
1613         test-tool chmtime --get .git/index >out &&
1614         grep ^1234567890 out &&
1615         git status &&
1616         test-tool chmtime --get .git/index >out &&
1617         ! grep ^1234567890 out
1618 '
1619
1620 test_done