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