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