t/t7810-grep.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2006 Junio C Hamano
   4 #
   5
   6 test_description='git grep various.
   7 '
   8
   9 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
  10 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
  11
  12 . ./test-lib.sh
  13
  14 test_invalid_grep_expression() {
  15         params="$@" &&
  16         test_expect_success "invalid expression: grep $params" '
  17                 test_must_fail git grep $params -- nonexisting
  18         '
  19 }
  20
  21 LC_ALL=en_US.UTF-8 test-tool regex '^.$' '¿' &&
  22   test_set_prereq MB_REGEX
  23
  24 cat >hello.c <<EOF
  25 #include <assert.h>
  26 #include <stdio.h>
  27
  28 int main(int argc, const char **argv)
  29 {
  30         printf("Hello world.\n");
  31         return 0;
  32         /* char ?? */
  33 }
  34 EOF
  35
  36 test_expect_success setup '
  37         cat >file <<-\EOF &&
  38         foo mmap bar
  39         foo_mmap bar
  40         foo_mmap bar mmap
  41         foo mmap bar_mmap
  42         foo_mmap bar mmap baz
  43         EOF
  44         cat >hello_world <<-\EOF &&
  45         Hello world
  46         HeLLo world
  47         Hello_world
  48         HeLLo_world
  49         EOF
  50         cat >ab <<-\EOF &&
  51         a+b*c
  52         a+bc
  53         abc
  54         EOF
  55         cat >d0 <<-\EOF &&
  56         d
  57         0
  58         EOF
  59         echo vvv >v &&
  60         echo ww w >w &&
  61         echo x x xx x >x &&
  62         echo y yy >y &&
  63         echo zzz > z &&
  64         mkdir t &&
  65         echo test >t/t &&
  66         echo vvv >t/v &&
  67         mkdir t/a &&
  68         echo vvv >t/a/v &&
  69         qz_to_tab_space >space <<-\EOF &&
  70         line without leading space1
  71         Zline with leading space1
  72         Zline with leading space2
  73         Zline with leading space3
  74         line without leading space2
  75         EOF
  76         cat >hello.ps1 <<-\EOF &&
  77         # No-op.
  78         function dummy() {}
  79
  80         # Say hello.
  81         function hello() {
  82           echo "Hello world."
  83           echo "Hello again."
  84         } # hello
  85
  86         # Still a no-op.
  87         function dummy() {}
  88         EOF
  89         if test_have_prereq FUNNYNAMES
  90         then
  91                 echo unusual >"\"unusual\" pathname" &&
  92                 echo unusual >"t/nested \"unusual\" pathname"
  93         fi &&
  94         if test_have_prereq MB_REGEX
  95         then
  96                 echo "¿" >reverse-question-mark
  97         fi &&
  98         git add . &&
  99         test_tick &&
 100         git commit -m initial
 101 '
 102
 103 test_expect_success 'grep should not segfault with a bad input' '
 104         test_must_fail git grep "("
 105 '
 106
 107 test_invalid_grep_expression --and -e A
 108
 109 test_pattern_type () {
 110         H=$1 &&
 111         HC=$2 &&
 112         L=$3 &&
 113         type=$4 &&
 114         shift 4 &&
 115
 116         expected_str= &&
 117         case "$type" in
 118         BRE)
 119                 expected_str="${HC}ab:a+bc"
 120                 ;;
 121         ERE)
 122                 expected_str="${HC}ab:abc"
 123                 ;;
 124         FIX)
 125                 expected_str="${HC}ab:a+b*c"
 126                 ;;
 127         *)
 128                 BUG "unknown pattern type '$type'"
 129                 ;;
 130         esac &&
 131         config_str="$@" &&
 132
 133         test_expect_success "grep $L with '$config_str' interpreted as $type" '
 134                 echo $expected_str >expected &&
 135                 git $config_str grep "a+b*c" $H ab >actual &&
 136                 test_cmp expected actual
 137         '
 138 }
 139
 140 for H in HEAD ''
 141 do
 142         case "$H" in
 143         HEAD)   HC='HEAD:' L='HEAD' ;;
 144         '')     HC= L='in working tree' ;;
 145         esac
 146
 147         test_expect_success "grep -w $L" '
 148                 cat >expected <<-EOF &&
 149                 ${HC}file:1:foo mmap bar
 150                 ${HC}file:3:foo_mmap bar mmap
 151                 ${HC}file:4:foo mmap bar_mmap
 152                 ${HC}file:5:foo_mmap bar mmap baz
 153                 EOF
 154                 git -c grep.linenumber=false grep -n -w -e mmap $H >actual &&
 155                 test_cmp expected actual
 156         '
 157
 158         test_expect_success "grep -w $L (with --column)" '
 159                 cat >expected <<-EOF &&
 160                 ${HC}file:5:foo mmap bar
 161                 ${HC}file:14:foo_mmap bar mmap
 162                 ${HC}file:5:foo mmap bar_mmap
 163                 ${HC}file:14:foo_mmap bar mmap baz
 164                 EOF
 165                 git grep --column -w -e mmap $H >actual &&
 166                 test_cmp expected actual
 167         '
 168
 169         test_expect_success "grep -w $L (with --column, extended OR)" '
 170                 cat >expected <<-EOF &&
 171                 ${HC}file:14:foo_mmap bar mmap
 172                 ${HC}file:19:foo_mmap bar mmap baz
 173                 EOF
 174                 git grep --column -w -e mmap$ --or -e baz $H >actual &&
 175                 test_cmp expected actual
 176         '
 177
 178         test_expect_success "grep -w $L (with --column, --invert-match)" '
 179                 cat >expected <<-EOF &&
 180                 ${HC}file:1:foo mmap bar
 181                 ${HC}file:1:foo_mmap bar
 182                 ${HC}file:1:foo_mmap bar mmap
 183                 ${HC}file:1:foo mmap bar_mmap
 184                 EOF
 185                 git grep --column --invert-match -w -e baz $H -- file >actual &&
 186                 test_cmp expected actual
 187         '
 188
 189         test_expect_success "grep $L (with --column, --invert-match, extended OR)" '
 190                 cat >expected <<-EOF &&
 191                 ${HC}hello_world:6:HeLLo_world
 192                 EOF
 193                 git grep --column --invert-match -e ll --or --not -e _ $H -- hello_world \
 194                         >actual &&
 195                 test_cmp expected actual
 196         '
 197
 198         test_expect_success "grep $L (with --column, --invert-match, extended AND)" '
 199                 cat >expected <<-EOF &&
 200                 ${HC}hello_world:3:Hello world
 201                 ${HC}hello_world:3:Hello_world
 202                 ${HC}hello_world:6:HeLLo_world
 203                 EOF
 204                 git grep --column --invert-match --not -e _ --and --not -e ll $H -- hello_world \
 205                         >actual &&
 206                 test_cmp expected actual
 207         '
 208
 209         test_expect_success "grep $L (with --column, double-negation)" '
 210                 cat >expected <<-EOF &&
 211                 ${HC}file:1:foo_mmap bar mmap baz
 212                 EOF
 213                 git grep --column --not \( --not -e foo --or --not -e baz \) $H -- file \
 214                         >actual &&
 215                 test_cmp expected actual
 216         '
 217
 218         test_expect_success "grep -w $L (with --column, -C)" '
 219                 cat >expected <<-EOF &&
 220                 ${HC}file:5:foo mmap bar
 221                 ${HC}file-foo_mmap bar
 222                 ${HC}file:14:foo_mmap bar mmap
 223                 ${HC}file:5:foo mmap bar_mmap
 224                 ${HC}file:14:foo_mmap bar mmap baz
 225                 EOF
 226                 git grep --column -w -C1 -e mmap $H >actual &&
 227                 test_cmp expected actual
 228         '
 229
 230         test_expect_success "grep -w $L (with --line-number, --column)" '
 231                 cat >expected <<-EOF &&
 232                 ${HC}file:1:5:foo mmap bar
 233                 ${HC}file:3:14:foo_mmap bar mmap
 234                 ${HC}file:4:5:foo mmap bar_mmap
 235                 ${HC}file:5:14:foo_mmap bar mmap baz
 236                 EOF
 237                 git grep -n --column -w -e mmap $H >actual &&
 238                 test_cmp expected actual
 239         '
 240
 241         test_expect_success "grep -w $L (with non-extended patterns, --column)" '
 242                 cat >expected <<-EOF &&
 243                 ${HC}file:5:foo mmap bar
 244                 ${HC}file:10:foo_mmap bar
 245                 ${HC}file:10:foo_mmap bar mmap
 246                 ${HC}file:5:foo mmap bar_mmap
 247                 ${HC}file:10:foo_mmap bar mmap baz
 248                 EOF
 249                 git grep --column -w -e bar -e mmap $H >actual &&
 250                 test_cmp expected actual
 251         '
 252
 253         test_expect_success "grep -w $L" '
 254                 cat >expected <<-EOF &&
 255                 ${HC}file:1:foo mmap bar
 256                 ${HC}file:3:foo_mmap bar mmap
 257                 ${HC}file:4:foo mmap bar_mmap
 258                 ${HC}file:5:foo_mmap bar mmap baz
 259                 EOF
 260                 git -c grep.linenumber=true grep -w -e mmap $H >actual &&
 261                 test_cmp expected actual
 262         '
 263
 264         test_expect_success "grep -w $L" '
 265                 cat >expected <<-EOF &&
 266                 ${HC}file:foo mmap bar
 267                 ${HC}file:foo_mmap bar mmap
 268                 ${HC}file:foo mmap bar_mmap
 269                 ${HC}file:foo_mmap bar mmap baz
 270                 EOF
 271                 git -c grep.linenumber=true grep --no-line-number -w -e mmap $H >actual &&
 272                 test_cmp expected actual
 273         '
 274
 275         test_expect_success "grep -w $L (w)" '
 276                 test_must_fail git grep -n -w -e "^w" $H >actual &&
 277                 test_must_be_empty actual
 278         '
 279
 280         test_expect_success "grep -w $L (x)" '
 281                 cat >expected <<-EOF &&
 282                 ${HC}x:1:x x xx x
 283                 EOF
 284                 git grep -n -w -e "x xx* x" $H >actual &&
 285                 test_cmp expected actual
 286         '
 287
 288         test_expect_success "grep -w $L (y-1)" '
 289                 cat >expected <<-EOF &&
 290                 ${HC}y:1:y yy
 291                 EOF
 292                 git grep -n -w -e "^y" $H >actual &&
 293                 test_cmp expected actual
 294         '
 295
 296         test_expect_success "grep -w $L (y-2)" '
 297                 if git grep -n -w -e "^y y" $H >actual
 298                 then
 299                         echo should not have matched
 300                         cat actual
 301                         false
 302                 else
 303                         test_must_be_empty actual
 304                 fi
 305         '
 306
 307         test_expect_success "grep -w $L (z)" '
 308                 if git grep -n -w -e "^z" $H >actual
 309                 then
 310                         echo should not have matched
 311                         cat actual
 312                         false
 313                 else
 314                         test_must_be_empty actual
 315                 fi
 316         '
 317
 318         test_expect_success "grep $L (with --column, --only-matching)" '
 319                 cat >expected <<-EOF &&
 320                 ${HC}file:1:5:mmap
 321                 ${HC}file:2:5:mmap
 322                 ${HC}file:3:5:mmap
 323                 ${HC}file:3:13:mmap
 324                 ${HC}file:4:5:mmap
 325                 ${HC}file:4:13:mmap
 326                 ${HC}file:5:5:mmap
 327                 ${HC}file:5:13:mmap
 328                 EOF
 329                 git grep --column -n -o -e mmap $H >actual &&
 330                 test_cmp expected actual
 331         '
 332
 333         test_expect_success "grep $L (t-1)" '
 334                 echo "${HC}t/t:1:test" >expected &&
 335                 git grep -n -e test $H >actual &&
 336                 test_cmp expected actual
 337         '
 338
 339         test_expect_success "grep $L (t-2)" '
 340                 echo "${HC}t:1:test" >expected &&
 341                 (
 342                         cd t &&
 343                         git grep -n -e test $H
 344                 ) >actual &&
 345                 test_cmp expected actual
 346         '
 347
 348         test_expect_success "grep $L (t-3)" '
 349                 echo "${HC}t/t:1:test" >expected &&
 350                 (
 351                         cd t &&
 352                         git grep --full-name -n -e test $H
 353                 ) >actual &&
 354                 test_cmp expected actual
 355         '
 356
 357         test_expect_success "grep -c $L (no /dev/null)" '
 358                 ! git grep -c test $H | grep /dev/null
 359         '
 360
 361         test_expect_success "grep --max-depth -1 $L" '
 362                 cat >expected <<-EOF &&
 363                 ${HC}t/a/v:1:vvv
 364                 ${HC}t/v:1:vvv
 365                 ${HC}v:1:vvv
 366                 EOF
 367                 git grep --max-depth -1 -n -e vvv $H >actual &&
 368                 test_cmp expected actual &&
 369                 git grep --recursive -n -e vvv $H >actual &&
 370                 test_cmp expected actual
 371         '
 372
 373         test_expect_success "grep --max-depth 0 $L" '
 374                 cat >expected <<-EOF &&
 375                 ${HC}v:1:vvv
 376                 EOF
 377                 git grep --max-depth 0 -n -e vvv $H >actual &&
 378                 test_cmp expected actual &&
 379                 git grep --no-recursive -n -e vvv $H >actual &&
 380                 test_cmp expected actual
 381         '
 382
 383         test_expect_success "grep --max-depth 0 -- '*' $L" '
 384                 cat >expected <<-EOF &&
 385                 ${HC}t/a/v:1:vvv
 386                 ${HC}t/v:1:vvv
 387                 ${HC}v:1:vvv
 388                 EOF
 389                 git grep --max-depth 0 -n -e vvv $H -- "*" >actual &&
 390                 test_cmp expected actual &&
 391                 git grep --no-recursive -n -e vvv $H -- "*" >actual &&
 392                 test_cmp expected actual
 393         '
 394
 395         test_expect_success "grep --max-depth 1 $L" '
 396                 cat >expected <<-EOF &&
 397                 ${HC}t/v:1:vvv
 398                 ${HC}v:1:vvv
 399                 EOF
 400                 git grep --max-depth 1 -n -e vvv $H >actual &&
 401                 test_cmp expected actual
 402         '
 403
 404         test_expect_success "grep --max-depth 0 -- t $L" '
 405                 cat >expected <<-EOF &&
 406                 ${HC}t/v:1:vvv
 407                 EOF
 408                 git grep --max-depth 0 -n -e vvv $H -- t >actual &&
 409                 test_cmp expected actual &&
 410                 git grep --no-recursive -n -e vvv $H -- t >actual &&
 411                 test_cmp expected actual
 412         '
 413
 414         test_expect_success "grep --max-depth 0 -- . t $L" '
 415                 cat >expected <<-EOF &&
 416                 ${HC}t/v:1:vvv
 417                 ${HC}v:1:vvv
 418                 EOF
 419                 git grep --max-depth 0 -n -e vvv $H -- . t >actual &&
 420                 test_cmp expected actual &&
 421                 git grep --no-recursive -n -e vvv $H -- . t >actual &&
 422                 test_cmp expected actual
 423         '
 424
 425         test_expect_success "grep --max-depth 0 -- t . $L" '
 426                 cat >expected <<-EOF &&
 427                 ${HC}t/v:1:vvv
 428                 ${HC}v:1:vvv
 429                 EOF
 430                 git grep --max-depth 0 -n -e vvv $H -- t . >actual &&
 431                 test_cmp expected actual &&
 432                 git grep --no-recursive -n -e vvv $H -- t . >actual &&
 433                 test_cmp expected actual
 434         '
 435
 436
 437         test_pattern_type "$H" "$HC" "$L" BRE -c grep.extendedRegexp=false
 438         test_pattern_type "$H" "$HC" "$L" ERE -c grep.extendedRegexp=true
 439         test_pattern_type "$H" "$HC" "$L" BRE -c grep.patternType=basic
 440         test_pattern_type "$H" "$HC" "$L" ERE -c grep.patternType=extended
 441         test_pattern_type "$H" "$HC" "$L" FIX -c grep.patternType=fixed
 442
 443         test_expect_success PCRE "grep $L with grep.patterntype=perl" '
 444                 echo "${HC}ab:a+b*c" >expected &&
 445                 git -c grep.patterntype=perl grep "a\x{2b}b\x{2a}c" $H ab >actual &&
 446                 test_cmp expected actual
 447         '
 448
 449         test_expect_success !FAIL_PREREQS,!PCRE "grep $L with grep.patterntype=perl errors without PCRE" '
 450                 test_must_fail git -c grep.patterntype=perl grep "foo.*bar"
 451         '
 452
 453         test_pattern_type "$H" "$HC" "$L" ERE \
 454                 -c grep.patternType=default \
 455                 -c grep.extendedRegexp=true
 456         test_pattern_type "$H" "$HC" "$L" ERE \
 457                 -c grep.extendedRegexp=true \
 458                 -c grep.patternType=default
 459         test_pattern_type "$H" "$HC" "$L" ERE \
 460                 -c grep.patternType=extended \
 461                 -c grep.extendedRegexp=false
 462         test_pattern_type "$H" "$HC" "$L" BRE \
 463                 -c grep.patternType=basic \
 464                 -c grep.extendedRegexp=true
 465         test_pattern_type "$H" "$HC" "$L" ERE \
 466                 -c grep.extendedRegexp=false \
 467                 -c grep.patternType=extended
 468         test_pattern_type "$H" "$HC" "$L" BRE \
 469                 -c grep.extendedRegexp=true \
 470                 -c grep.patternType=basic
 471
 472         # grep.extendedRegexp is last-one-wins
 473         test_pattern_type "$H" "$HC" "$L" BRE \
 474                 -c grep.extendedRegexp=true \
 475                 -c grep.extendedRegexp=false
 476
 477         # grep.patternType=basic pays no attention to grep.extendedRegexp
 478         test_pattern_type "$H" "$HC" "$L" BRE \
 479                 -c grep.extendedRegexp=true \
 480                 -c grep.patternType=basic \
 481                 -c grep.extendedRegexp=false
 482
 483         # grep.patternType=extended pays no attention to grep.extendedRegexp
 484         test_pattern_type "$H" "$HC" "$L" ERE \
 485                 -c grep.extendedRegexp=true \
 486                 -c grep.patternType=extended \
 487                 -c grep.extendedRegexp=false
 488
 489         # grep.extendedRegexp is used with a last-one-wins grep.patternType=default
 490         test_pattern_type "$H" "$HC" "$L" ERE \
 491                 -c grep.patternType=fixed \
 492                 -c grep.extendedRegexp=true \
 493                 -c grep.patternType=default
 494
 495         # grep.extendedRegexp is used with earlier grep.patternType=default
 496         test_pattern_type "$H" "$HC" "$L" ERE \
 497                 -c grep.extendedRegexp=false \
 498                 -c grep.patternType=default \
 499                 -c grep.extendedRegexp=true
 500
 501         # grep.extendedRegexp is used with a last-one-loses grep.patternType=default
 502         test_pattern_type "$H" "$HC" "$L" ERE \
 503                 -c grep.extendedRegexp=false \
 504                 -c grep.extendedRegexp=true \
 505                 -c grep.patternType=default
 506
 507         # grep.extendedRegexp and grep.patternType are both last-one-wins independently
 508         test_pattern_type "$H" "$HC" "$L" BRE \
 509                 -c grep.patternType=default \
 510                 -c grep.extendedRegexp=true \
 511                 -c grep.patternType=basic
 512
 513         # grep.patternType=extended and grep.patternType=default
 514         test_pattern_type "$H" "$HC" "$L" BRE \
 515                 -c grep.patternType=extended \
 516                 -c grep.patternType=default
 517
 518         # grep.patternType=[extended -> default -> fixed] (BRE)" '
 519         test_pattern_type "$H" "$HC" "$L" FIX \
 520                 -c grep.patternType=extended \
 521                 -c grep.patternType=default \
 522                 -c grep.patternType=fixed
 523
 524         test_expect_success "grep --count $L" '
 525                 echo ${HC}ab:3 >expected &&
 526                 git grep --count -e b $H -- ab >actual &&
 527                 test_cmp expected actual
 528         '
 529
 530         test_expect_success "grep --count -h $L" '
 531                 echo 3 >expected &&
 532                 git grep --count -h -e b $H -- ab >actual &&
 533                 test_cmp expected actual
 534         '
 535
 536         test_expect_success FUNNYNAMES "grep $L should quote unusual pathnames" '
 537                 cat >expected <<-EOF &&
 538                 ${HC}"\"unusual\" pathname":unusual
 539                 ${HC}"t/nested \"unusual\" pathname":unusual
 540                 EOF
 541                 git grep unusual $H >actual &&
 542                 test_cmp expected actual
 543         '
 544
 545         test_expect_success FUNNYNAMES "grep $L in subdir should quote unusual relative pathnames" '
 546                 cat >expected <<-EOF &&
 547                 ${HC}"nested \"unusual\" pathname":unusual
 548                 EOF
 549                 (
 550                         cd t &&
 551                         git grep unusual $H
 552                 ) >actual &&
 553                 test_cmp expected actual
 554         '
 555
 556         test_expect_success FUNNYNAMES "grep -z $L with unusual pathnames" '
 557                 cat >expected <<-EOF &&
 558                 ${HC}"unusual" pathname:unusual
 559                 ${HC}t/nested "unusual" pathname:unusual
 560                 EOF
 561                 git grep -z unusual $H >actual &&
 562                 tr "\0" ":" <actual >actual-replace-null &&
 563                 test_cmp expected actual-replace-null
 564         '
 565
 566         test_expect_success FUNNYNAMES "grep -z $L in subdir with unusual relative pathnames" '
 567                 cat >expected <<-EOF &&
 568                 ${HC}nested "unusual" pathname:unusual
 569                 EOF
 570                 (
 571                         cd t &&
 572                         git grep -z unusual $H
 573                 ) >actual &&
 574                 tr "\0" ":" <actual >actual-replace-null &&
 575                 test_cmp expected actual-replace-null
 576         '
 577 done
 578
 579 test_expect_success MB_REGEX 'grep exactly one char in single-char multibyte file' '
 580         LC_ALL=en_US.UTF-8 git grep "^.$" reverse-question-mark
 581 '
 582
 583 test_expect_success MB_REGEX 'grep two chars in single-char multibyte file' '
 584         LC_ALL=en_US.UTF-8 test_expect_code 1 git grep ".." reverse-question-mark
 585 '
 586
 587 cat >expected <<EOF
 588 file
 589 EOF
 590 test_expect_success 'grep -l -C' '
 591         git grep -l -C1 foo >actual &&
 592         test_cmp expected actual
 593 '
 594
 595 cat >expected <<EOF
 596 file:5
 597 EOF
 598 test_expect_success 'grep -c -C' '
 599         git grep -c -C1 foo >actual &&
 600         test_cmp expected actual
 601 '
 602
 603 test_expect_success 'grep -L -C' '
 604         git ls-files >expected &&
 605         git grep -L -C1 nonexistent_string >actual &&
 606         test_cmp expected actual
 607 '
 608
 609 test_expect_success 'grep --files-without-match --quiet' '
 610         git grep --files-without-match --quiet nonexistent_string >actual &&
 611         test_must_be_empty actual
 612 '
 613
 614 test_expect_success 'grep --max-count 0 (must exit with non-zero)' '
 615         test_must_fail git grep --max-count 0 foo >actual &&
 616         test_must_be_empty actual
 617 '
 618
 619 test_expect_success 'grep --max-count 3' '
 620         cat >expected <<-EOF &&
 621         file:foo mmap bar
 622         file:foo_mmap bar
 623         file:foo_mmap bar mmap
 624         EOF
 625         git grep --max-count 3 foo >actual &&
 626         test_cmp expected actual
 627 '
 628
 629 test_expect_success 'grep --max-count -1 (no limit)' '
 630         cat >expected <<-EOF &&
 631         file:foo mmap bar
 632         file:foo_mmap bar
 633         file:foo_mmap bar mmap
 634         file:foo mmap bar_mmap
 635         file:foo_mmap bar mmap baz
 636         EOF
 637         git grep --max-count -1 foo >actual &&
 638         test_cmp expected actual
 639 '
 640
 641 test_expect_success 'grep --max-count 1 --context 2' '
 642         cat >expected <<-EOF &&
 643         file-foo mmap bar
 644         file:foo_mmap bar
 645         file-foo_mmap bar mmap
 646         EOF
 647         git grep --max-count 1 --context 1 foo_mmap >actual &&
 648         test_cmp expected actual
 649 '
 650
 651 test_expect_success 'grep --max-count 1 --show-function' '
 652         cat >expected <<-EOF &&
 653         hello.ps1=function hello() {
 654         hello.ps1:  echo "Hello world."
 655         EOF
 656         git grep --max-count 1 --show-function Hello hello.ps1 >actual &&
 657         test_cmp expected actual
 658 '
 659
 660 test_expect_success 'grep --max-count 2 --show-function' '
 661         cat >expected <<-EOF &&
 662         hello.ps1=function hello() {
 663         hello.ps1:  echo "Hello world."
 664         hello.ps1:  echo "Hello again."
 665         EOF
 666         git grep --max-count 2 --show-function Hello hello.ps1 >actual &&
 667         test_cmp expected actual
 668 '
 669
 670 test_expect_success 'grep --max-count 1 --count' '
 671         cat >expected <<-EOF &&
 672         hello.ps1:1
 673         EOF
 674         git grep --max-count 1 --count Hello hello.ps1 >actual &&
 675         test_cmp expected actual
 676 '
 677
 678 test_expect_success 'grep --max-count 1 (multiple files)' '
 679         cat >expected <<-EOF &&
 680         hello.c:#include <stdio.h>
 681         hello.ps1:# No-op.
 682         EOF
 683         git grep --max-count 1 -e o -- hello.\* >actual &&
 684         test_cmp expected actual
 685 '
 686
 687 test_expect_success 'grep --max-count 1 --context 1 (multiple files)' '
 688         cat >expected <<-EOF &&
 689         hello.c-#include <assert.h>
 690         hello.c:#include <stdio.h>
 691         hello.c-
 692         --
 693         hello.ps1:# No-op.
 694         hello.ps1-function dummy() {}
 695         EOF
 696         git grep --max-count 1 --context 1 -e o -- hello.\* >actual &&
 697         test_cmp expected actual
 698 '
 699
 700 cat >expected <<EOF
 701 file:foo mmap bar_mmap
 702 EOF
 703
 704 test_expect_success 'grep -e A --and -e B' '
 705         git grep -e "foo mmap" --and -e bar_mmap >actual &&
 706         test_cmp expected actual
 707 '
 708
 709 cat >expected <<EOF
 710 file:foo_mmap bar mmap
 711 file:foo_mmap bar mmap baz
 712 EOF
 713
 714
 715 test_expect_success 'grep ( -e A --or -e B ) --and -e B' '
 716         git grep \( -e foo_ --or -e baz \) \
 717                 --and -e " mmap" >actual &&
 718         test_cmp expected actual
 719 '
 720
 721 cat >expected <<EOF
 722 file:foo mmap bar
 723 EOF
 724
 725 test_expect_success 'grep -e A --and --not -e B' '
 726         git grep -e "foo mmap" --and --not -e bar_mmap >actual &&
 727         test_cmp expected actual
 728 '
 729
 730 test_expect_success 'grep should ignore GREP_OPTIONS' '
 731         GREP_OPTIONS=-v git grep " mmap bar\$" >actual &&
 732         test_cmp expected actual
 733 '
 734
 735 test_expect_success 'grep -f, non-existent file' '
 736         test_must_fail git grep -f patterns
 737 '
 738
 739 cat >expected <<EOF
 740 file:foo mmap bar
 741 file:foo_mmap bar
 742 file:foo_mmap bar mmap
 743 file:foo mmap bar_mmap
 744 file:foo_mmap bar mmap baz
 745 EOF
 746
 747 cat >pattern <<EOF
 748 mmap
 749 EOF
 750
 751 test_expect_success 'grep -f, one pattern' '
 752         git grep -f pattern >actual &&
 753         test_cmp expected actual
 754 '
 755
 756 cat >expected <<EOF
 757 file:foo mmap bar
 758 file:foo_mmap bar
 759 file:foo_mmap bar mmap
 760 file:foo mmap bar_mmap
 761 file:foo_mmap bar mmap baz
 762 t/a/v:vvv
 763 t/v:vvv
 764 v:vvv
 765 EOF
 766
 767 cat >patterns <<EOF
 768 mmap
 769 vvv
 770 EOF
 771
 772 test_expect_success 'grep -f, multiple patterns' '
 773         git grep -f patterns >actual &&
 774         test_cmp expected actual
 775 '
 776
 777 test_expect_success 'grep, multiple patterns' '
 778         git grep "$(cat patterns)" >actual &&
 779         test_cmp expected actual
 780 '
 781
 782 cat >expected <<EOF
 783 file:foo mmap bar
 784 file:foo_mmap bar
 785 file:foo_mmap bar mmap
 786 file:foo mmap bar_mmap
 787 file:foo_mmap bar mmap baz
 788 t/a/v:vvv
 789 t/v:vvv
 790 v:vvv
 791 EOF
 792
 793 cat >patterns <<EOF
 794
 795 mmap
 796
 797 vvv
 798
 799 EOF
 800
 801 test_expect_success 'grep -f, ignore empty lines' '
 802         git grep -f patterns >actual &&
 803         test_cmp expected actual
 804 '
 805
 806 test_expect_success 'grep -f, ignore empty lines, read patterns from stdin' '
 807         git grep -f - <patterns >actual &&
 808         test_cmp expected actual
 809 '
 810
 811 cat >expected <<EOF
 812 y:y yy
 813 --
 814 z:zzz
 815 EOF
 816
 817 test_expect_success 'grep -q, silently report matches' '
 818         git grep -q mmap >actual &&
 819         test_must_be_empty actual &&
 820         test_must_fail git grep -q qfwfq >actual &&
 821         test_must_be_empty actual
 822 '
 823
 824 test_expect_success 'grep -C1 hunk mark between files' '
 825         git grep -C1 "^[yz]" >actual &&
 826         test_cmp expected actual
 827 '
 828
 829 test_expect_success 'log grep setup' '
 830         test_commit --append --author "With * Asterisk <xyzzy@frotz.com>" second file a &&
 831         test_commit --append third file a &&
 832         test_commit --append --author "Night Fall <nitfol@frobozz.com>" fourth file a
 833 '
 834
 835 test_expect_success 'log grep (1)' '
 836         git log --author=author --pretty=tformat:%s >actual &&
 837         {
 838                 echo third && echo initial
 839         } >expect &&
 840         test_cmp expect actual
 841 '
 842
 843 test_expect_success 'log grep (2)' '
 844         git log --author=" * " -F --pretty=tformat:%s >actual &&
 845         {
 846                 echo second
 847         } >expect &&
 848         test_cmp expect actual
 849 '
 850
 851 test_expect_success 'log grep (3)' '
 852         git log --author="^A U" --pretty=tformat:%s >actual &&
 853         {
 854                 echo third && echo initial
 855         } >expect &&
 856         test_cmp expect actual
 857 '
 858
 859 test_expect_success 'log grep (4)' '
 860         git log --author="frotz\.com>$" --pretty=tformat:%s >actual &&
 861         {
 862                 echo second
 863         } >expect &&
 864         test_cmp expect actual
 865 '
 866
 867 test_expect_success 'log grep (5)' '
 868         git log --author=Thor -F --pretty=tformat:%s >actual &&
 869         {
 870                 echo third && echo initial
 871         } >expect &&
 872         test_cmp expect actual
 873 '
 874
 875 test_expect_success 'log grep (6)' '
 876         git log --author=-0700  --pretty=tformat:%s >actual &&
 877         test_must_be_empty actual
 878 '
 879
 880 test_expect_success 'log grep (7)' '
 881         git log -g --grep-reflog="commit: third" --pretty=tformat:%s >actual &&
 882         echo third >expect &&
 883         test_cmp expect actual
 884 '
 885
 886 test_expect_success 'log grep (8)' '
 887         git log -g --grep-reflog="commit: third" --grep-reflog="commit: second" --pretty=tformat:%s >actual &&
 888         {
 889                 echo third && echo second
 890         } >expect &&
 891         test_cmp expect actual
 892 '
 893
 894 test_expect_success 'log grep (9)' '
 895         git log -g --grep-reflog="commit: third" --author="Thor" --pretty=tformat:%s >actual &&
 896         echo third >expect &&
 897         test_cmp expect actual
 898 '
 899
 900 test_expect_success 'log grep (9)' '
 901         git log -g --grep-reflog="commit: third" --author="non-existent" --pretty=tformat:%s >actual &&
 902         test_must_be_empty actual
 903 '
 904
 905 test_expect_success 'log --grep-reflog can only be used under -g' '
 906         test_must_fail git log --grep-reflog="commit: third"
 907 '
 908
 909 test_expect_success 'log with multiple --grep uses union' '
 910         git log --grep=i --grep=r --format=%s >actual &&
 911         {
 912                 echo fourth && echo third && echo initial
 913         } >expect &&
 914         test_cmp expect actual
 915 '
 916
 917 test_expect_success 'log --all-match with multiple --grep uses intersection' '
 918         git log --all-match --grep=i --grep=r --format=%s >actual &&
 919         {
 920                 echo third
 921         } >expect &&
 922         test_cmp expect actual
 923 '
 924
 925 test_expect_success 'log with multiple --author uses union' '
 926         git log --author="Thor" --author="Aster" --format=%s >actual &&
 927         {
 928             echo third && echo second && echo initial
 929         } >expect &&
 930         test_cmp expect actual
 931 '
 932
 933 test_expect_success 'log --all-match with multiple --author still uses union' '
 934         git log --all-match --author="Thor" --author="Aster" --format=%s >actual &&
 935         {
 936             echo third && echo second && echo initial
 937         } >expect &&
 938         test_cmp expect actual
 939 '
 940
 941 test_expect_success 'log --grep --author uses intersection' '
 942         # grep matches only third and fourth
 943         # author matches only initial and third
 944         git log --author="A U Thor" --grep=r --format=%s >actual &&
 945         {
 946                 echo third
 947         } >expect &&
 948         test_cmp expect actual
 949 '
 950
 951 test_expect_success 'log --grep --grep --author takes union of greps and intersects with author' '
 952         # grep matches initial and second but not third
 953         # author matches only initial and third
 954         git log --author="A U Thor" --grep=s --grep=l --format=%s >actual &&
 955         {
 956                 echo initial
 957         } >expect &&
 958         test_cmp expect actual
 959 '
 960
 961 test_expect_success 'log ---all-match -grep --author --author still takes union of authors and intersects with grep' '
 962         # grep matches only initial and third
 963         # author matches all but second
 964         git log --all-match --author="Thor" --author="Night" --grep=i --format=%s >actual &&
 965         {
 966             echo third && echo initial
 967         } >expect &&
 968         test_cmp expect actual
 969 '
 970
 971 test_expect_success 'log --grep --author --author takes union of authors and intersects with grep' '
 972         # grep matches only initial and third
 973         # author matches all but second
 974         git log --author="Thor" --author="Night" --grep=i --format=%s >actual &&
 975         {
 976             echo third && echo initial
 977         } >expect &&
 978         test_cmp expect actual
 979 '
 980
 981 test_expect_success 'log --all-match --grep --grep --author takes intersection' '
 982         # grep matches only third
 983         # author matches only initial and third
 984         git log --all-match --author="A U Thor" --grep=i --grep=r --format=%s >actual &&
 985         {
 986                 echo third
 987         } >expect &&
 988         test_cmp expect actual
 989 '
 990
 991 test_expect_success 'log --author does not search in timestamp' '
 992         git log --author="$GIT_AUTHOR_DATE" >actual &&
 993         test_must_be_empty actual
 994 '
 995
 996 test_expect_success 'log --committer does not search in timestamp' '
 997         git log --committer="$GIT_COMMITTER_DATE" >actual &&
 998         test_must_be_empty actual
 999 '
1000
1001 test_expect_success 'grep with CE_VALID file' '
1002         git update-index --assume-unchanged t/t &&
1003         rm t/t &&
1004         test "$(git grep test)" = "t/t:test" &&
1005         git update-index --no-assume-unchanged t/t &&
1006         git checkout t/t
1007 '
1008
1009 cat >expected <<EOF
1010 hello.c=#include <stdio.h>
1011 hello.c:        return 0;
1012 EOF
1013
1014 test_expect_success 'grep -p with userdiff' '
1015         git config diff.custom.funcname "^#" &&
1016         echo "hello.c diff=custom" >.gitattributes &&
1017         git grep -p return >actual &&
1018         test_cmp expected actual
1019 '
1020
1021 cat >expected <<EOF
1022 hello.c=int main(int argc, const char **argv)
1023 hello.c:        return 0;
1024 EOF
1025
1026 test_expect_success 'grep -p' '
1027         rm -f .gitattributes &&
1028         git grep -p return >actual &&
1029         test_cmp expected actual
1030 '
1031
1032 cat >expected <<EOF
1033 hello.c-#include <stdio.h>
1034 hello.c-
1035 hello.c=int main(int argc, const char **argv)
1036 hello.c-{
1037 hello.c-        printf("Hello world.\n");
1038 hello.c:        return 0;
1039 EOF
1040
1041 test_expect_success 'grep -p -B5' '
1042         git grep -p -B5 return >actual &&
1043         test_cmp expected actual
1044 '
1045
1046 cat >expected <<EOF
1047 hello.c=int main(int argc, const char **argv)
1048 hello.c-{
1049 hello.c-        printf("Hello world.\n");
1050 hello.c:        return 0;
1051 hello.c-        /* char ?? */
1052 hello.c-}
1053 EOF
1054
1055 test_expect_success 'grep -W' '
1056         git grep -W return >actual &&
1057         test_cmp expected actual
1058 '
1059
1060 cat >expected <<EOF
1061 hello.c-#include <assert.h>
1062 hello.c:#include <stdio.h>
1063 EOF
1064
1065 test_expect_success 'grep -W shows no trailing empty lines' '
1066         git grep -W stdio >actual &&
1067         test_cmp expected actual
1068 '
1069
1070 test_expect_success 'grep -W with userdiff' '
1071         test_when_finished "rm -f .gitattributes" &&
1072         git config diff.custom.xfuncname "^function .*$" &&
1073         echo "hello.ps1 diff=custom" >.gitattributes &&
1074         git grep -W echo >function-context-userdiff-actual
1075 '
1076
1077 test_expect_success ' includes preceding comment' '
1078         grep "# Say hello" function-context-userdiff-actual
1079 '
1080
1081 test_expect_success ' includes function line' '
1082         grep "=function hello" function-context-userdiff-actual
1083 '
1084
1085 test_expect_success ' includes matching line' '
1086         grep ":  echo" function-context-userdiff-actual
1087 '
1088
1089 test_expect_success ' includes last line of the function' '
1090         grep "} # hello" function-context-userdiff-actual
1091 '
1092
1093 for threads in $(test_seq 0 10)
1094 do
1095         test_expect_success "grep --threads=$threads & -c grep.threads=$threads" "
1096                 git grep --threads=$threads . >actual.$threads &&
1097                 if test $threads -ge 1
1098                 then
1099                         test_cmp actual.\$(($threads - 1)) actual.$threads
1100                 fi &&
1101                 git -c grep.threads=$threads grep . >actual.$threads &&
1102                 if test $threads -ge 1
1103                 then
1104                         test_cmp actual.\$(($threads - 1)) actual.$threads
1105                 fi
1106         "
1107 done
1108
1109 test_expect_success !PTHREADS,!FAIL_PREREQS \
1110         'grep --threads=N or pack.threads=N warns when no pthreads' '
1111         git grep --threads=2 Hello hello_world 2>err &&
1112         grep ^warning: err >warnings &&
1113         test_line_count = 1 warnings &&
1114         grep -F "no threads support, ignoring --threads" err &&
1115         git -c grep.threads=2 grep Hello hello_world 2>err &&
1116         grep ^warning: err >warnings &&
1117         test_line_count = 1 warnings &&
1118         grep -F "no threads support, ignoring grep.threads" err &&
1119         git -c grep.threads=2 grep --threads=4 Hello hello_world 2>err &&
1120         grep ^warning: err >warnings &&
1121         test_line_count = 2 warnings &&
1122         grep -F "no threads support, ignoring --threads" err &&
1123         grep -F "no threads support, ignoring grep.threads" err &&
1124         git -c grep.threads=0 grep --threads=0 Hello hello_world 2>err &&
1125         test_line_count = 0 err
1126 '
1127
1128 test_expect_success 'grep from a subdirectory to search wider area (1)' '
1129         mkdir -p s &&
1130         (
1131                 cd s && git grep "x x x" ..
1132         )
1133 '
1134
1135 test_expect_success 'grep from a subdirectory to search wider area (2)' '
1136         mkdir -p s &&
1137         (
1138                 cd s &&
1139                 test_expect_code 1 git grep xxyyzz .. >out &&
1140                 test_must_be_empty out
1141         )
1142 '
1143
1144 cat >expected <<EOF
1145 hello.c:int main(int argc, const char **argv)
1146 EOF
1147
1148 test_expect_success 'grep -Fi' '
1149         git grep -Fi "CHAR *" >actual &&
1150         test_cmp expected actual
1151 '
1152
1153 test_expect_success 'outside of git repository' '
1154         rm -fr non &&
1155         mkdir -p non/git/sub &&
1156         echo hello >non/git/file1 &&
1157         echo world >non/git/sub/file2 &&
1158         {
1159                 echo file1:hello &&
1160                 echo sub/file2:world
1161         } >non/expect.full &&
1162         echo file2:world >non/expect.sub &&
1163         (
1164                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1165                 export GIT_CEILING_DIRECTORIES &&
1166                 cd non/git &&
1167                 test_must_fail git grep o &&
1168                 git grep --no-index o >../actual.full &&
1169                 test_cmp ../expect.full ../actual.full &&
1170                 cd sub &&
1171                 test_must_fail git grep o &&
1172                 git grep --no-index o >../../actual.sub &&
1173                 test_cmp ../../expect.sub ../../actual.sub
1174         ) &&
1175
1176         echo ".*o*" >non/git/.gitignore &&
1177         (
1178                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1179                 export GIT_CEILING_DIRECTORIES &&
1180                 cd non/git &&
1181                 test_must_fail git grep o &&
1182                 git grep --no-index --exclude-standard o >../actual.full &&
1183                 test_cmp ../expect.full ../actual.full &&
1184
1185                 {
1186                         echo ".gitignore:.*o*" &&
1187                         cat ../expect.full
1188                 } >../expect.with.ignored &&
1189                 git grep --no-index --no-exclude-standard o >../actual.full &&
1190                 test_cmp ../expect.with.ignored ../actual.full
1191         )
1192 '
1193
1194 test_expect_success 'outside of git repository with fallbackToNoIndex' '
1195         rm -fr non &&
1196         mkdir -p non/git/sub &&
1197         echo hello >non/git/file1 &&
1198         echo world >non/git/sub/file2 &&
1199         cat <<-\EOF >non/expect.full &&
1200         file1:hello
1201         sub/file2:world
1202         EOF
1203         echo file2:world >non/expect.sub &&
1204         (
1205                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1206                 export GIT_CEILING_DIRECTORIES &&
1207                 cd non/git &&
1208                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1209                 git -c grep.fallbackToNoIndex=true grep o >../actual.full &&
1210                 test_cmp ../expect.full ../actual.full &&
1211                 cd sub &&
1212                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1213                 git -c grep.fallbackToNoIndex=true grep o >../../actual.sub &&
1214                 test_cmp ../../expect.sub ../../actual.sub
1215         ) &&
1216
1217         echo ".*o*" >non/git/.gitignore &&
1218         (
1219                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1220                 export GIT_CEILING_DIRECTORIES &&
1221                 cd non/git &&
1222                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1223                 git -c grep.fallbackToNoIndex=true grep --exclude-standard o >../actual.full &&
1224                 test_cmp ../expect.full ../actual.full &&
1225
1226                 {
1227                         echo ".gitignore:.*o*" &&
1228                         cat ../expect.full
1229                 } >../expect.with.ignored &&
1230                 git -c grep.fallbackToNoIndex grep --no-exclude-standard o >../actual.full &&
1231                 test_cmp ../expect.with.ignored ../actual.full
1232         )
1233 '
1234
1235 test_expect_success 'inside git repository but with --no-index' '
1236         rm -fr is &&
1237         mkdir -p is/git/sub &&
1238         echo hello >is/git/file1 &&
1239         echo world >is/git/sub/file2 &&
1240         echo ".*o*" >is/git/.gitignore &&
1241         {
1242                 echo file1:hello &&
1243                 echo sub/file2:world
1244         } >is/expect.unignored &&
1245         {
1246                 echo ".gitignore:.*o*" &&
1247                 cat is/expect.unignored
1248         } >is/expect.full &&
1249         echo file2:world >is/expect.sub &&
1250         (
1251                 cd is/git &&
1252                 git init &&
1253                 test_must_fail git grep o >../actual.full &&
1254                 test_must_be_empty ../actual.full &&
1255
1256                 git grep --untracked o >../actual.unignored &&
1257                 test_cmp ../expect.unignored ../actual.unignored &&
1258
1259                 git grep --no-index o >../actual.full &&
1260                 test_cmp ../expect.full ../actual.full &&
1261
1262                 git grep --no-index --exclude-standard o >../actual.unignored &&
1263                 test_cmp ../expect.unignored ../actual.unignored &&
1264
1265                 cd sub &&
1266                 test_must_fail git grep o >../../actual.sub &&
1267                 test_must_be_empty ../../actual.sub &&
1268
1269                 git grep --no-index o >../../actual.sub &&
1270                 test_cmp ../../expect.sub ../../actual.sub &&
1271
1272                 git grep --untracked o >../../actual.sub &&
1273                 test_cmp ../../expect.sub ../../actual.sub
1274         )
1275 '
1276
1277 test_expect_success 'grep --no-index descends into repos, but not .git' '
1278         rm -fr non &&
1279         mkdir -p non/git &&
1280         (
1281                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1282                 export GIT_CEILING_DIRECTORIES &&
1283                 cd non/git &&
1284
1285                 echo magic >file &&
1286                 git init repo &&
1287                 (
1288                         cd repo &&
1289                         echo magic >file &&
1290                         git add file &&
1291                         git commit -m foo &&
1292                         echo magic >.git/file
1293                 ) &&
1294
1295                 cat >expect <<-\EOF &&
1296                 file
1297                 repo/file
1298                 EOF
1299                 git grep -l --no-index magic >actual &&
1300                 test_cmp expect actual
1301         )
1302 '
1303
1304 test_expect_success 'setup double-dash tests' '
1305 cat >double-dash <<EOF &&
1306 --
1307 ->
1308 other
1309 EOF
1310 git add double-dash
1311 '
1312
1313 cat >expected <<EOF
1314 double-dash:->
1315 EOF
1316 test_expect_success 'grep -- pattern' '
1317         git grep -- "->" >actual &&
1318         test_cmp expected actual
1319 '
1320 test_expect_success 'grep -- pattern -- pathspec' '
1321         git grep -- "->" -- double-dash >actual &&
1322         test_cmp expected actual
1323 '
1324 test_expect_success 'grep -e pattern -- path' '
1325         git grep -e "->" -- double-dash >actual &&
1326         test_cmp expected actual
1327 '
1328
1329 cat >expected <<EOF
1330 double-dash:--
1331 EOF
1332 test_expect_success 'grep -e -- -- path' '
1333         git grep -e -- -- double-dash >actual &&
1334         test_cmp expected actual
1335 '
1336
1337 test_expect_success 'dashdash disambiguates rev as rev' '
1338         test_when_finished "rm -f main" &&
1339         echo content >main &&
1340         echo main:hello.c >expect &&
1341         git grep -l o main -- hello.c >actual &&
1342         test_cmp expect actual
1343 '
1344
1345 test_expect_success 'dashdash disambiguates pathspec as pathspec' '
1346         test_when_finished "git rm -f main" &&
1347         echo content >main &&
1348         git add main &&
1349         echo main:content >expect &&
1350         git grep o -- main >actual &&
1351         test_cmp expect actual
1352 '
1353
1354 test_expect_success 'report bogus arg without dashdash' '
1355         test_must_fail git grep o does-not-exist
1356 '
1357
1358 test_expect_success 'report bogus rev with dashdash' '
1359         test_must_fail git grep o hello.c --
1360 '
1361
1362 test_expect_success 'allow non-existent path with dashdash' '
1363         # We need a real match so grep exits with success.
1364         tree=$(git ls-tree HEAD |
1365                sed s/hello.c/not-in-working-tree/ |
1366                git mktree) &&
1367         git grep o "$tree" -- not-in-working-tree
1368 '
1369
1370 test_expect_success 'grep --no-index pattern -- path' '
1371         rm -fr non &&
1372         mkdir -p non/git &&
1373         (
1374                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1375                 export GIT_CEILING_DIRECTORIES &&
1376                 cd non/git &&
1377                 echo hello >hello &&
1378                 echo goodbye >goodbye &&
1379                 echo hello:hello >expect &&
1380                 git grep --no-index o -- hello >actual &&
1381                 test_cmp expect actual
1382         )
1383 '
1384
1385 test_expect_success 'grep --no-index complains of revs' '
1386         test_must_fail git grep --no-index o main -- 2>err &&
1387         test_i18ngrep "cannot be used with revs" err
1388 '
1389
1390 test_expect_success 'grep --no-index prefers paths to revs' '
1391         test_when_finished "rm -f main" &&
1392         echo content >main &&
1393         echo main:content >expect &&
1394         git grep --no-index o main >actual &&
1395         test_cmp expect actual
1396 '
1397
1398 test_expect_success 'grep --no-index does not "diagnose" revs' '
1399         test_must_fail git grep --no-index o :1:hello.c 2>err &&
1400         test_i18ngrep ! -i "did you mean" err
1401 '
1402
1403 cat >expected <<EOF
1404 hello.c:int main(int argc, const char **argv)
1405 hello.c:        printf("Hello world.\n");
1406 EOF
1407
1408 test_expect_success PCRE 'grep --perl-regexp pattern' '
1409         git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1410         test_cmp expected actual
1411 '
1412
1413 test_expect_success !FAIL_PREREQS,!PCRE 'grep --perl-regexp pattern errors without PCRE' '
1414         test_must_fail git grep --perl-regexp "foo.*bar"
1415 '
1416
1417 test_expect_success PCRE 'grep -P pattern' '
1418         git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1419         test_cmp expected actual
1420 '
1421
1422 test_expect_success LIBPCRE2 "grep -P with (*NO_JIT) doesn't error out" '
1423         git grep -P "(*NO_JIT)\p{Ps}.*?\p{Pe}" hello.c >actual &&
1424         test_cmp expected actual
1425
1426 '
1427
1428 test_expect_success !FAIL_PREREQS,!PCRE 'grep -P pattern errors without PCRE' '
1429         test_must_fail git grep -P "foo.*bar"
1430 '
1431
1432 test_expect_success 'grep pattern with grep.extendedRegexp=true' '
1433         test_must_fail git -c grep.extendedregexp=true \
1434                 grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1435         test_must_be_empty actual
1436 '
1437
1438 test_expect_success PCRE 'grep -P pattern with grep.extendedRegexp=true' '
1439         git -c grep.extendedregexp=true \
1440                 grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1441         test_cmp expected actual
1442 '
1443
1444 test_expect_success PCRE 'grep -P -v pattern' '
1445         cat >expected <<-\EOF &&
1446         ab:a+b*c
1447         ab:a+bc
1448         EOF
1449         git grep -P -v "abc" ab >actual &&
1450         test_cmp expected actual
1451 '
1452
1453 test_expect_success PCRE 'grep -P -i pattern' '
1454         cat >expected <<-EOF &&
1455         hello.c:        printf("Hello world.\n");
1456         EOF
1457         git grep -P -i "PRINTF\([^\d]+\)" hello.c >actual &&
1458         test_cmp expected actual
1459 '
1460
1461 test_expect_success PCRE 'grep -P -w pattern' '
1462         cat >expected <<-\EOF &&
1463         hello_world:Hello world
1464         hello_world:HeLLo world
1465         EOF
1466         git grep -P -w "He((?i)ll)o" hello_world >actual &&
1467         test_cmp expected actual
1468 '
1469
1470 test_expect_success PCRE 'grep -P backreferences work (the PCRE NO_AUTO_CAPTURE flag is not set)' '
1471         git grep -P -h "(?P<one>.)(?P=one)" hello_world >actual &&
1472         test_cmp hello_world actual &&
1473         git grep -P -h "(.)\1" hello_world >actual &&
1474         test_cmp hello_world actual
1475 '
1476
1477 test_expect_success 'grep -G invalidpattern properly dies ' '
1478         test_must_fail git grep -G "a["
1479 '
1480
1481 test_expect_success 'grep invalidpattern properly dies with grep.patternType=basic' '
1482         test_must_fail git -c grep.patterntype=basic grep "a["
1483 '
1484
1485 test_expect_success 'grep -E invalidpattern properly dies ' '
1486         test_must_fail git grep -E "a["
1487 '
1488
1489 test_expect_success 'grep invalidpattern properly dies with grep.patternType=extended' '
1490         test_must_fail git -c grep.patterntype=extended grep "a["
1491 '
1492
1493 test_expect_success PCRE 'grep -P invalidpattern properly dies ' '
1494         test_must_fail git grep -P "a["
1495 '
1496
1497 test_expect_success PCRE 'grep invalidpattern properly dies with grep.patternType=perl' '
1498         test_must_fail git -c grep.patterntype=perl grep "a["
1499 '
1500
1501 test_expect_success 'grep -G -E -F pattern' '
1502         echo "ab:a+b*c" >expected &&
1503         git grep -G -E -F "a+b*c" ab >actual &&
1504         test_cmp expected actual
1505 '
1506
1507 test_expect_success 'grep pattern with grep.patternType=basic, =extended, =fixed' '
1508         echo "ab:a+b*c" >expected &&
1509         git \
1510                 -c grep.patterntype=basic \
1511                 -c grep.patterntype=extended \
1512                 -c grep.patterntype=fixed \
1513                 grep "a+b*c" ab >actual &&
1514         test_cmp expected actual
1515 '
1516
1517 test_expect_success 'grep -E -F -G pattern' '
1518         echo "ab:a+bc" >expected &&
1519         git grep -E -F -G "a+b*c" ab >actual &&
1520         test_cmp expected actual
1521 '
1522
1523 test_expect_success 'grep pattern with grep.patternType=extended, =fixed, =basic' '
1524         echo "ab:a+bc" >expected &&
1525         git \
1526                 -c grep.patterntype=extended \
1527                 -c grep.patterntype=fixed \
1528                 -c grep.patterntype=basic \
1529                 grep "a+b*c" ab >actual &&
1530         test_cmp expected actual
1531 '
1532
1533 test_expect_success 'grep -F -G -E pattern' '
1534         echo "ab:abc" >expected &&
1535         git grep -F -G -E "a+b*c" ab >actual &&
1536         test_cmp expected actual
1537 '
1538
1539 test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =extended' '
1540         echo "ab:abc" >expected &&
1541         git \
1542                 -c grep.patterntype=fixed \
1543                 -c grep.patterntype=basic \
1544                 -c grep.patterntype=extended \
1545                 grep "a+b*c" ab >actual &&
1546         test_cmp expected actual
1547 '
1548
1549 test_expect_success 'grep -G -F -P -E pattern' '
1550         echo "d0:d" >expected &&
1551         git grep -G -F -P -E "[\d]" d0 >actual &&
1552         test_cmp expected actual
1553 '
1554
1555 test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =perl, =extended' '
1556         echo "d0:d" >expected &&
1557         git \
1558                 -c grep.patterntype=fixed \
1559                 -c grep.patterntype=basic \
1560                 -c grep.patterntype=perl \
1561                 -c grep.patterntype=extended \
1562                 grep "[\d]" d0 >actual &&
1563         test_cmp expected actual
1564 '
1565
1566 test_expect_success PCRE 'grep -G -F -E -P pattern' '
1567         echo "d0:0" >expected &&
1568         git grep -G -F -E -P "[\d]" d0 >actual &&
1569         test_cmp expected actual
1570 '
1571
1572 test_expect_success PCRE 'grep pattern with grep.patternType=fixed, =basic, =extended, =perl' '
1573         echo "d0:0" >expected &&
1574         git \
1575                 -c grep.patterntype=fixed \
1576                 -c grep.patterntype=basic \
1577                 -c grep.patterntype=extended \
1578                 -c grep.patterntype=perl \
1579                 grep "[\d]" d0 >actual &&
1580         test_cmp expected actual
1581 '
1582
1583 test_expect_success PCRE 'grep -P pattern with grep.patternType=fixed' '
1584         echo "ab:a+b*c" >expected &&
1585         git \
1586                 -c grep.patterntype=fixed \
1587                 grep -P "a\x{2b}b\x{2a}c" ab >actual &&
1588         test_cmp expected actual
1589 '
1590
1591 test_expect_success 'grep -F pattern with grep.patternType=basic' '
1592         echo "ab:a+b*c" >expected &&
1593         git \
1594                 -c grep.patterntype=basic \
1595                 grep -F "*c" ab >actual &&
1596         test_cmp expected actual
1597 '
1598
1599 test_expect_success 'grep -G pattern with grep.patternType=fixed' '
1600         cat >expected <<-\EOF &&
1601         ab:a+b*c
1602         ab:a+bc
1603         EOF
1604         git \
1605                 -c grep.patterntype=fixed \
1606                 grep -G "a+b" ab >actual &&
1607         test_cmp expected actual
1608 '
1609
1610 test_expect_success 'grep -E pattern with grep.patternType=fixed' '
1611         cat >expected <<-\EOF &&
1612         ab:a+b*c
1613         ab:a+bc
1614         ab:abc
1615         EOF
1616         git \
1617                 -c grep.patterntype=fixed \
1618                 grep -E "a+" ab >actual &&
1619         test_cmp expected actual
1620 '
1621
1622 cat >expected <<EOF
1623 hello.c<RED>:<RESET>int main(int argc, const char **argv)
1624 hello.c<RED>-<RESET>{
1625 <RED>--<RESET>
1626 hello.c<RED>:<RESET>    /* char ?? */
1627 hello.c<RED>-<RESET>}
1628 <RED>--<RESET>
1629 hello_world<RED>:<RESET>Hello_world
1630 hello_world<RED>-<RESET>HeLLo_world
1631 EOF
1632
1633 test_expect_success 'grep --color, separator' '
1634         test_config color.grep.context          normal &&
1635         test_config color.grep.filename         normal &&
1636         test_config color.grep.function         normal &&
1637         test_config color.grep.linenumber       normal &&
1638         test_config color.grep.match            normal &&
1639         test_config color.grep.selected         normal &&
1640         test_config color.grep.separator        red &&
1641
1642         git grep --color=always -A1 -e char -e lo_w hello.c hello_world |
1643         test_decode_color >actual &&
1644         test_cmp expected actual
1645 '
1646
1647 cat >expected <<EOF
1648 hello.c:int main(int argc, const char **argv)
1649 hello.c:        /* char ?? */
1650
1651 hello_world:Hello_world
1652 EOF
1653
1654 test_expect_success 'grep --break' '
1655         git grep --break -e char -e lo_w hello.c hello_world >actual &&
1656         test_cmp expected actual
1657 '
1658
1659 cat >expected <<EOF
1660 hello.c:int main(int argc, const char **argv)
1661 hello.c-{
1662 --
1663 hello.c:        /* char ?? */
1664 hello.c-}
1665
1666 hello_world:Hello_world
1667 hello_world-HeLLo_world
1668 EOF
1669
1670 test_expect_success 'grep --break with context' '
1671         git grep --break -A1 -e char -e lo_w hello.c hello_world >actual &&
1672         test_cmp expected actual
1673 '
1674
1675 cat >expected <<EOF
1676 hello.c
1677 int main(int argc, const char **argv)
1678         /* char ?? */
1679 hello_world
1680 Hello_world
1681 EOF
1682
1683 test_expect_success 'grep --heading' '
1684         git grep --heading -e char -e lo_w hello.c hello_world >actual &&
1685         test_cmp expected actual
1686 '
1687
1688 cat >expected <<EOF
1689 <BOLD;GREEN>hello.c<RESET>
1690 4:int main(int argc, const <BLACK;BYELLOW>char<RESET> **argv)
1691 8:      /* <BLACK;BYELLOW>char<RESET> ?? */
1692
1693 <BOLD;GREEN>hello_world<RESET>
1694 3:Hel<BLACK;BYELLOW>lo_w<RESET>orld
1695 EOF
1696
1697 test_expect_success 'mimic ack-grep --group' '
1698         test_config color.grep.context          normal &&
1699         test_config color.grep.filename         "bold green" &&
1700         test_config color.grep.function         normal &&
1701         test_config color.grep.linenumber       normal &&
1702         test_config color.grep.match            "black yellow" &&
1703         test_config color.grep.selected         normal &&
1704         test_config color.grep.separator        normal &&
1705
1706         git grep --break --heading -n --color \
1707                 -e char -e lo_w hello.c hello_world |
1708         test_decode_color >actual &&
1709         test_cmp expected actual
1710 '
1711
1712 cat >expected <<EOF
1713 space: line with leading space1
1714 space: line with leading space2
1715 space: line with leading space3
1716 EOF
1717
1718 test_expect_success PCRE 'grep -E "^ "' '
1719         git grep -E "^ " space >actual &&
1720         test_cmp expected actual
1721 '
1722
1723 test_expect_success PCRE 'grep -P "^ "' '
1724         git grep -P "^ " space >actual &&
1725         test_cmp expected actual
1726 '
1727
1728 cat >expected <<EOF
1729 space-line without leading space1
1730 space: line <RED>with <RESET>leading space1
1731 space: line <RED>with <RESET>leading <RED>space2<RESET>
1732 space: line <RED>with <RESET>leading space3
1733 space:line without leading <RED>space2<RESET>
1734 EOF
1735
1736 test_expect_success 'grep --color -e A -e B with context' '
1737         test_config color.grep.context          normal &&
1738         test_config color.grep.filename         normal &&
1739         test_config color.grep.function         normal &&
1740         test_config color.grep.linenumber       normal &&
1741         test_config color.grep.matchContext     normal &&
1742         test_config color.grep.matchSelected    red &&
1743         test_config color.grep.selected         normal &&
1744         test_config color.grep.separator        normal &&
1745
1746         git grep --color=always -C2 -e "with " -e space2  space |
1747         test_decode_color >actual &&
1748         test_cmp expected actual
1749 '
1750
1751 cat >expected <<EOF
1752 space-line without leading space1
1753 space- line with leading space1
1754 space: line <RED>with <RESET>leading <RED>space2<RESET>
1755 space- line with leading space3
1756 space-line without leading space2
1757 EOF
1758
1759 test_expect_success 'grep --color -e A --and -e B with context' '
1760         test_config color.grep.context          normal &&
1761         test_config color.grep.filename         normal &&
1762         test_config color.grep.function         normal &&
1763         test_config color.grep.linenumber       normal &&
1764         test_config color.grep.matchContext     normal &&
1765         test_config color.grep.matchSelected    red &&
1766         test_config color.grep.selected         normal &&
1767         test_config color.grep.separator        normal &&
1768
1769         git grep --color=always -C2 -e "with " --and -e space2  space |
1770         test_decode_color >actual &&
1771         test_cmp expected actual
1772 '
1773
1774 cat >expected <<EOF
1775 space-line without leading space1
1776 space: line <RED>with <RESET>leading space1
1777 space- line with leading space2
1778 space: line <RED>with <RESET>leading space3
1779 space-line without leading space2
1780 EOF
1781
1782 test_expect_success 'grep --color -e A --and --not -e B with context' '
1783         test_config color.grep.context          normal &&
1784         test_config color.grep.filename         normal &&
1785         test_config color.grep.function         normal &&
1786         test_config color.grep.linenumber       normal &&
1787         test_config color.grep.matchContext     normal &&
1788         test_config color.grep.matchSelected    red &&
1789         test_config color.grep.selected         normal &&
1790         test_config color.grep.separator        normal &&
1791
1792         git grep --color=always -C2 -e "with " --and --not -e space2  space |
1793         test_decode_color >actual &&
1794         test_cmp expected actual
1795 '
1796
1797 cat >expected <<EOF
1798 hello.c-
1799 hello.c=int main(int argc, const char **argv)
1800 hello.c-{
1801 hello.c:        pr<RED>int<RESET>f("<RED>Hello<RESET> world.\n");
1802 hello.c-        return 0;
1803 hello.c-        /* char ?? */
1804 hello.c-}
1805 EOF
1806
1807 test_expect_success 'grep --color -e A --and -e B -p with context' '
1808         test_config color.grep.context          normal &&
1809         test_config color.grep.filename         normal &&
1810         test_config color.grep.function         normal &&
1811         test_config color.grep.linenumber       normal &&
1812         test_config color.grep.matchContext     normal &&
1813         test_config color.grep.matchSelected    red &&
1814         test_config color.grep.selected         normal &&
1815         test_config color.grep.separator        normal &&
1816
1817         git grep --color=always -p -C3 -e int --and -e Hello --no-index hello.c |
1818         test_decode_color >actual &&
1819         test_cmp expected actual
1820 '
1821
1822 test_expect_success 'grep can find things only in the work tree' '
1823         : >work-tree-only &&
1824         git add work-tree-only &&
1825         test_when_finished "git rm -f work-tree-only" &&
1826         echo "find in work tree" >work-tree-only &&
1827         git grep --quiet "find in work tree" &&
1828         test_must_fail git grep --quiet --cached "find in work tree" &&
1829         test_must_fail git grep --quiet "find in work tree" HEAD
1830 '
1831
1832 test_expect_success 'grep can find things only in the work tree (i-t-a)' '
1833         echo "intend to add this" >intend-to-add &&
1834         git add -N intend-to-add &&
1835         test_when_finished "git rm -f intend-to-add" &&
1836         git grep --quiet "intend to add this" &&
1837         test_must_fail git grep --quiet --cached "intend to add this" &&
1838         test_must_fail git grep --quiet "intend to add this" HEAD
1839 '
1840
1841 test_expect_success 'grep does not search work tree with assume unchanged' '
1842         echo "intend to add this" >intend-to-add &&
1843         git add -N intend-to-add &&
1844         git update-index --assume-unchanged intend-to-add &&
1845         test_when_finished "git rm -f intend-to-add" &&
1846         test_must_fail git grep --quiet "intend to add this" &&
1847         test_must_fail git grep --quiet --cached "intend to add this" &&
1848         test_must_fail git grep --quiet "intend to add this" HEAD
1849 '
1850
1851 test_expect_success 'grep can find things only in the index' '
1852         echo "only in the index" >cache-this &&
1853         git add cache-this &&
1854         rm cache-this &&
1855         test_when_finished "git rm --cached cache-this" &&
1856         test_must_fail git grep --quiet "only in the index" &&
1857         git grep --quiet --cached "only in the index" &&
1858         test_must_fail git grep --quiet "only in the index" HEAD
1859 '
1860
1861 test_expect_success 'grep does not report i-t-a with -L --cached' '
1862         echo "intend to add this" >intend-to-add &&
1863         git add -N intend-to-add &&
1864         test_when_finished "git rm -f intend-to-add" &&
1865         git ls-files | grep -v "^intend-to-add\$" >expected &&
1866         git grep -L --cached "nonexistent_string" >actual &&
1867         test_cmp expected actual
1868 '
1869
1870 test_expect_success 'grep does not report i-t-a and assume unchanged with -L' '
1871         echo "intend to add this" >intend-to-add-assume-unchanged &&
1872         git add -N intend-to-add-assume-unchanged &&
1873         test_when_finished "git rm -f intend-to-add-assume-unchanged" &&
1874         git update-index --assume-unchanged intend-to-add-assume-unchanged &&
1875         git ls-files | grep -v "^intend-to-add-assume-unchanged\$" >expected &&
1876         git grep -L "nonexistent_string" >actual &&
1877         test_cmp expected actual
1878 '
1879
1880 test_done