git.oblomov.eu Git - git/blob - 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 'grep --threads=N or pack.threads=N warns when no pthreads' '
 973         git grep --threads=2 Hello hello_world 2>err &&
 974         grep ^warning: err >warnings &&
 975         test_line_count = 1 warnings &&
 976         grep -F "no threads support, ignoring --threads" err &&
 977         git -c grep.threads=2 grep Hello hello_world 2>err &&
 978         grep ^warning: err >warnings &&
 979         test_line_count = 1 warnings &&
 980         grep -F "no threads support, ignoring grep.threads" err &&
 981         git -c grep.threads=2 grep --threads=4 Hello hello_world 2>err &&
 982         grep ^warning: err >warnings &&
 983         test_line_count = 2 warnings &&
 984         grep -F "no threads support, ignoring --threads" err &&
 985         grep -F "no threads support, ignoring grep.threads" err &&
 986         git -c grep.threads=0 grep --threads=0 Hello hello_world 2>err &&
 987         test_line_count = 0 err
 988 '
 989
 990 test_expect_success 'grep from a subdirectory to search wider area (1)' '
 991         mkdir -p s &&
 992         (
 993                 cd s && git grep "x x x" ..
 994         )
 995 '
 996
 997 test_expect_success 'grep from a subdirectory to search wider area (2)' '
 998         mkdir -p s &&
 999         (
1000                 cd s &&
1001                 test_expect_code 1 git grep xxyyzz .. >out &&
1002                 test_must_be_empty out
1003         )
1004 '
1005
1006 cat >expected <<EOF
1007 hello.c:int main(int argc, const char **argv)
1008 EOF
1009
1010 test_expect_success 'grep -Fi' '
1011         git grep -Fi "CHAR *" >actual &&
1012         test_cmp expected actual
1013 '
1014
1015 test_expect_success 'outside of git repository' '
1016         rm -fr non &&
1017         mkdir -p non/git/sub &&
1018         echo hello >non/git/file1 &&
1019         echo world >non/git/sub/file2 &&
1020         {
1021                 echo file1:hello &&
1022                 echo sub/file2:world
1023         } >non/expect.full &&
1024         echo file2:world >non/expect.sub &&
1025         (
1026                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1027                 export GIT_CEILING_DIRECTORIES &&
1028                 cd non/git &&
1029                 test_must_fail git grep o &&
1030                 git grep --no-index o >../actual.full &&
1031                 test_cmp ../expect.full ../actual.full &&
1032                 cd sub &&
1033                 test_must_fail git grep o &&
1034                 git grep --no-index o >../../actual.sub &&
1035                 test_cmp ../../expect.sub ../../actual.sub
1036         ) &&
1037
1038         echo ".*o*" >non/git/.gitignore &&
1039         (
1040                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1041                 export GIT_CEILING_DIRECTORIES &&
1042                 cd non/git &&
1043                 test_must_fail git grep o &&
1044                 git grep --no-index --exclude-standard o >../actual.full &&
1045                 test_cmp ../expect.full ../actual.full &&
1046
1047                 {
1048                         echo ".gitignore:.*o*" &&
1049                         cat ../expect.full
1050                 } >../expect.with.ignored &&
1051                 git grep --no-index --no-exclude-standard o >../actual.full &&
1052                 test_cmp ../expect.with.ignored ../actual.full
1053         )
1054 '
1055
1056 test_expect_success 'outside of git repository with fallbackToNoIndex' '
1057         rm -fr non &&
1058         mkdir -p non/git/sub &&
1059         echo hello >non/git/file1 &&
1060         echo world >non/git/sub/file2 &&
1061         cat <<-\EOF >non/expect.full &&
1062         file1:hello
1063         sub/file2:world
1064         EOF
1065         echo file2:world >non/expect.sub &&
1066         (
1067                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1068                 export GIT_CEILING_DIRECTORIES &&
1069                 cd non/git &&
1070                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1071                 git -c grep.fallbackToNoIndex=true grep o >../actual.full &&
1072                 test_cmp ../expect.full ../actual.full &&
1073                 cd sub &&
1074                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1075                 git -c grep.fallbackToNoIndex=true grep o >../../actual.sub &&
1076                 test_cmp ../../expect.sub ../../actual.sub
1077         ) &&
1078
1079         echo ".*o*" >non/git/.gitignore &&
1080         (
1081                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1082                 export GIT_CEILING_DIRECTORIES &&
1083                 cd non/git &&
1084                 test_must_fail git -c grep.fallbackToNoIndex=false grep o &&
1085                 git -c grep.fallbackToNoIndex=true grep --exclude-standard o >../actual.full &&
1086                 test_cmp ../expect.full ../actual.full &&
1087
1088                 {
1089                         echo ".gitignore:.*o*" &&
1090                         cat ../expect.full
1091                 } >../expect.with.ignored &&
1092                 git -c grep.fallbackToNoIndex grep --no-exclude-standard o >../actual.full &&
1093                 test_cmp ../expect.with.ignored ../actual.full
1094         )
1095 '
1096
1097 test_expect_success 'inside git repository but with --no-index' '
1098         rm -fr is &&
1099         mkdir -p is/git/sub &&
1100         echo hello >is/git/file1 &&
1101         echo world >is/git/sub/file2 &&
1102         echo ".*o*" >is/git/.gitignore &&
1103         {
1104                 echo file1:hello &&
1105                 echo sub/file2:world
1106         } >is/expect.unignored &&
1107         {
1108                 echo ".gitignore:.*o*" &&
1109                 cat is/expect.unignored
1110         } >is/expect.full &&
1111         echo file2:world >is/expect.sub &&
1112         (
1113                 cd is/git &&
1114                 git init &&
1115                 test_must_fail git grep o >../actual.full &&
1116                 test_must_be_empty ../actual.full &&
1117
1118                 git grep --untracked o >../actual.unignored &&
1119                 test_cmp ../expect.unignored ../actual.unignored &&
1120
1121                 git grep --no-index o >../actual.full &&
1122                 test_cmp ../expect.full ../actual.full &&
1123
1124                 git grep --no-index --exclude-standard o >../actual.unignored &&
1125                 test_cmp ../expect.unignored ../actual.unignored &&
1126
1127                 cd sub &&
1128                 test_must_fail git grep o >../../actual.sub &&
1129                 test_must_be_empty ../../actual.sub &&
1130
1131                 git grep --no-index o >../../actual.sub &&
1132                 test_cmp ../../expect.sub ../../actual.sub &&
1133
1134                 git grep --untracked o >../../actual.sub &&
1135                 test_cmp ../../expect.sub ../../actual.sub
1136         )
1137 '
1138
1139 test_expect_success 'grep --no-index descends into repos, but not .git' '
1140         rm -fr non &&
1141         mkdir -p non/git &&
1142         (
1143                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1144                 export GIT_CEILING_DIRECTORIES &&
1145                 cd non/git &&
1146
1147                 echo magic >file &&
1148                 git init repo &&
1149                 (
1150                         cd repo &&
1151                         echo magic >file &&
1152                         git add file &&
1153                         git commit -m foo &&
1154                         echo magic >.git/file
1155                 ) &&
1156
1157                 cat >expect <<-\EOF &&
1158                 file
1159                 repo/file
1160                 EOF
1161                 git grep -l --no-index magic >actual &&
1162                 test_cmp expect actual
1163         )
1164 '
1165
1166 test_expect_success 'setup double-dash tests' '
1167 cat >double-dash <<EOF &&
1168 --
1169 ->
1170 other
1171 EOF
1172 git add double-dash
1173 '
1174
1175 cat >expected <<EOF
1176 double-dash:->
1177 EOF
1178 test_expect_success 'grep -- pattern' '
1179         git grep -- "->" >actual &&
1180         test_cmp expected actual
1181 '
1182 test_expect_success 'grep -- pattern -- pathspec' '
1183         git grep -- "->" -- double-dash >actual &&
1184         test_cmp expected actual
1185 '
1186 test_expect_success 'grep -e pattern -- path' '
1187         git grep -e "->" -- double-dash >actual &&
1188         test_cmp expected actual
1189 '
1190
1191 cat >expected <<EOF
1192 double-dash:--
1193 EOF
1194 test_expect_success 'grep -e -- -- path' '
1195         git grep -e -- -- double-dash >actual &&
1196         test_cmp expected actual
1197 '
1198
1199 test_expect_success 'dashdash disambiguates rev as rev' '
1200         test_when_finished "rm -f main" &&
1201         echo content >main &&
1202         echo main:hello.c >expect &&
1203         git grep -l o main -- hello.c >actual &&
1204         test_cmp expect actual
1205 '
1206
1207 test_expect_success 'dashdash disambiguates pathspec as pathspec' '
1208         test_when_finished "git rm -f main" &&
1209         echo content >main &&
1210         git add main &&
1211         echo main:content >expect &&
1212         git grep o -- main >actual &&
1213         test_cmp expect actual
1214 '
1215
1216 test_expect_success 'report bogus arg without dashdash' '
1217         test_must_fail git grep o does-not-exist
1218 '
1219
1220 test_expect_success 'report bogus rev with dashdash' '
1221         test_must_fail git grep o hello.c --
1222 '
1223
1224 test_expect_success 'allow non-existent path with dashdash' '
1225         # We need a real match so grep exits with success.
1226         tree=$(git ls-tree HEAD |
1227                sed s/hello.c/not-in-working-tree/ |
1228                git mktree) &&
1229         git grep o "$tree" -- not-in-working-tree
1230 '
1231
1232 test_expect_success 'grep --no-index pattern -- path' '
1233         rm -fr non &&
1234         mkdir -p non/git &&
1235         (
1236                 GIT_CEILING_DIRECTORIES="$(pwd)/non" &&
1237                 export GIT_CEILING_DIRECTORIES &&
1238                 cd non/git &&
1239                 echo hello >hello &&
1240                 echo goodbye >goodbye &&
1241                 echo hello:hello >expect &&
1242                 git grep --no-index o -- hello >actual &&
1243                 test_cmp expect actual
1244         )
1245 '
1246
1247 test_expect_success 'grep --no-index complains of revs' '
1248         test_must_fail git grep --no-index o main -- 2>err &&
1249         test_i18ngrep "cannot be used with revs" err
1250 '
1251
1252 test_expect_success 'grep --no-index prefers paths to revs' '
1253         test_when_finished "rm -f main" &&
1254         echo content >main &&
1255         echo main:content >expect &&
1256         git grep --no-index o main >actual &&
1257         test_cmp expect actual
1258 '
1259
1260 test_expect_success 'grep --no-index does not "diagnose" revs' '
1261         test_must_fail git grep --no-index o :1:hello.c 2>err &&
1262         test_i18ngrep ! -i "did you mean" err
1263 '
1264
1265 cat >expected <<EOF
1266 hello.c:int main(int argc, const char **argv)
1267 hello.c:        printf("Hello world.\n");
1268 EOF
1269
1270 test_expect_success PCRE 'grep --perl-regexp pattern' '
1271         git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1272         test_cmp expected actual
1273 '
1274
1275 test_expect_success !FAIL_PREREQS,!PCRE 'grep --perl-regexp pattern errors without PCRE' '
1276         test_must_fail git grep --perl-regexp "foo.*bar"
1277 '
1278
1279 test_expect_success PCRE 'grep -P pattern' '
1280         git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1281         test_cmp expected actual
1282 '
1283
1284 test_expect_success LIBPCRE2 "grep -P with (*NO_JIT) doesn't error out" '
1285         git grep -P "(*NO_JIT)\p{Ps}.*?\p{Pe}" hello.c >actual &&
1286         test_cmp expected actual
1287
1288 '
1289
1290 test_expect_success !FAIL_PREREQS,!PCRE 'grep -P pattern errors without PCRE' '
1291         test_must_fail git grep -P "foo.*bar"
1292 '
1293
1294 test_expect_success 'grep pattern with grep.extendedRegexp=true' '
1295         test_must_fail git -c grep.extendedregexp=true \
1296                 grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1297         test_must_be_empty actual
1298 '
1299
1300 test_expect_success PCRE 'grep -P pattern with grep.extendedRegexp=true' '
1301         git -c grep.extendedregexp=true \
1302                 grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
1303         test_cmp expected actual
1304 '
1305
1306 test_expect_success PCRE 'grep -P -v pattern' '
1307         {
1308                 echo "ab:a+b*c"
1309                 echo "ab:a+bc"
1310         } >expected &&
1311         git grep -P -v "abc" ab >actual &&
1312         test_cmp expected actual
1313 '
1314
1315 test_expect_success PCRE 'grep -P -i pattern' '
1316         cat >expected <<-EOF &&
1317         hello.c:        printf("Hello world.\n");
1318         EOF
1319         git grep -P -i "PRINTF\([^\d]+\)" hello.c >actual &&
1320         test_cmp expected actual
1321 '
1322
1323 test_expect_success PCRE 'grep -P -w pattern' '
1324         {
1325                 echo "hello_world:Hello world"
1326                 echo "hello_world:HeLLo world"
1327         } >expected &&
1328         git grep -P -w "He((?i)ll)o" hello_world >actual &&
1329         test_cmp expected actual
1330 '
1331
1332 test_expect_success PCRE 'grep -P backreferences work (the PCRE NO_AUTO_CAPTURE flag is not set)' '
1333         git grep -P -h "(?P<one>.)(?P=one)" hello_world >actual &&
1334         test_cmp hello_world actual &&
1335         git grep -P -h "(.)\1" hello_world >actual &&
1336         test_cmp hello_world actual
1337 '
1338
1339 test_expect_success 'grep -G invalidpattern properly dies ' '
1340         test_must_fail git grep -G "a["
1341 '
1342
1343 test_expect_success 'grep invalidpattern properly dies with grep.patternType=basic' '
1344         test_must_fail git -c grep.patterntype=basic grep "a["
1345 '
1346
1347 test_expect_success 'grep -E invalidpattern properly dies ' '
1348         test_must_fail git grep -E "a["
1349 '
1350
1351 test_expect_success 'grep invalidpattern properly dies with grep.patternType=extended' '
1352         test_must_fail git -c grep.patterntype=extended grep "a["
1353 '
1354
1355 test_expect_success PCRE 'grep -P invalidpattern properly dies ' '
1356         test_must_fail git grep -P "a["
1357 '
1358
1359 test_expect_success PCRE 'grep invalidpattern properly dies with grep.patternType=perl' '
1360         test_must_fail git -c grep.patterntype=perl grep "a["
1361 '
1362
1363 test_expect_success 'grep -G -E -F pattern' '
1364         echo "ab:a+b*c" >expected &&
1365         git grep -G -E -F "a+b*c" ab >actual &&
1366         test_cmp expected actual
1367 '
1368
1369 test_expect_success 'grep pattern with grep.patternType=basic, =extended, =fixed' '
1370         echo "ab:a+b*c" >expected &&
1371         git \
1372                 -c grep.patterntype=basic \
1373                 -c grep.patterntype=extended \
1374                 -c grep.patterntype=fixed \
1375                 grep "a+b*c" ab >actual &&
1376         test_cmp expected actual
1377 '
1378
1379 test_expect_success 'grep -E -F -G pattern' '
1380         echo "ab:a+bc" >expected &&
1381         git grep -E -F -G "a+b*c" ab >actual &&
1382         test_cmp expected actual
1383 '
1384
1385 test_expect_success 'grep pattern with grep.patternType=extended, =fixed, =basic' '
1386         echo "ab:a+bc" >expected &&
1387         git \
1388                 -c grep.patterntype=extended \
1389                 -c grep.patterntype=fixed \
1390                 -c grep.patterntype=basic \
1391                 grep "a+b*c" ab >actual &&
1392         test_cmp expected actual
1393 '
1394
1395 test_expect_success 'grep -F -G -E pattern' '
1396         echo "ab:abc" >expected &&
1397         git grep -F -G -E "a+b*c" ab >actual &&
1398         test_cmp expected actual
1399 '
1400
1401 test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =extended' '
1402         echo "ab:abc" >expected &&
1403         git \
1404                 -c grep.patterntype=fixed \
1405                 -c grep.patterntype=basic \
1406                 -c grep.patterntype=extended \
1407                 grep "a+b*c" ab >actual &&
1408         test_cmp expected actual
1409 '
1410
1411 test_expect_success 'grep -G -F -P -E pattern' '
1412         echo "d0:d" >expected &&
1413         git grep -G -F -P -E "[\d]" d0 >actual &&
1414         test_cmp expected actual
1415 '
1416
1417 test_expect_success 'grep pattern with grep.patternType=fixed, =basic, =perl, =extended' '
1418         echo "d0:d" >expected &&
1419         git \
1420                 -c grep.patterntype=fixed \
1421                 -c grep.patterntype=basic \
1422                 -c grep.patterntype=perl \
1423                 -c grep.patterntype=extended \
1424                 grep "[\d]" d0 >actual &&
1425         test_cmp expected actual
1426 '
1427
1428 test_expect_success PCRE 'grep -G -F -E -P pattern' '
1429         echo "d0:0" >expected &&
1430         git grep -G -F -E -P "[\d]" d0 >actual &&
1431         test_cmp expected actual
1432 '
1433
1434 test_expect_success PCRE 'grep pattern with grep.patternType=fixed, =basic, =extended, =perl' '
1435         echo "d0:0" >expected &&
1436         git \
1437                 -c grep.patterntype=fixed \
1438                 -c grep.patterntype=basic \
1439                 -c grep.patterntype=extended \
1440                 -c grep.patterntype=perl \
1441                 grep "[\d]" d0 >actual &&
1442         test_cmp expected actual
1443 '
1444
1445 test_expect_success PCRE 'grep -P pattern with grep.patternType=fixed' '
1446         echo "ab:a+b*c" >expected &&
1447         git \
1448                 -c grep.patterntype=fixed \
1449                 grep -P "a\x{2b}b\x{2a}c" ab >actual &&
1450         test_cmp expected actual
1451 '
1452
1453 test_expect_success 'grep -F pattern with grep.patternType=basic' '
1454         echo "ab:a+b*c" >expected &&
1455         git \
1456                 -c grep.patterntype=basic \
1457                 grep -F "*c" ab >actual &&
1458         test_cmp expected actual
1459 '
1460
1461 test_expect_success 'grep -G pattern with grep.patternType=fixed' '
1462         {
1463                 echo "ab:a+b*c"
1464                 echo "ab:a+bc"
1465         } >expected &&
1466         git \
1467                 -c grep.patterntype=fixed \
1468                 grep -G "a+b" ab >actual &&
1469         test_cmp expected actual
1470 '
1471
1472 test_expect_success 'grep -E pattern with grep.patternType=fixed' '
1473         {
1474                 echo "ab:a+b*c"
1475                 echo "ab:a+bc"
1476                 echo "ab:abc"
1477         } >expected &&
1478         git \
1479                 -c grep.patterntype=fixed \
1480                 grep -E "a+" ab >actual &&
1481         test_cmp expected actual
1482 '
1483
1484 cat >expected <<EOF
1485 hello.c<RED>:<RESET>int main(int argc, const char **argv)
1486 hello.c<RED>-<RESET>{
1487 <RED>--<RESET>
1488 hello.c<RED>:<RESET>    /* char ?? */
1489 hello.c<RED>-<RESET>}
1490 <RED>--<RESET>
1491 hello_world<RED>:<RESET>Hello_world
1492 hello_world<RED>-<RESET>HeLLo_world
1493 EOF
1494
1495 test_expect_success 'grep --color, separator' '
1496         test_config color.grep.context          normal &&
1497         test_config color.grep.filename         normal &&
1498         test_config color.grep.function         normal &&
1499         test_config color.grep.linenumber       normal &&
1500         test_config color.grep.match            normal &&
1501         test_config color.grep.selected         normal &&
1502         test_config color.grep.separator        red &&
1503
1504         git grep --color=always -A1 -e char -e lo_w hello.c hello_world |
1505         test_decode_color >actual &&
1506         test_cmp expected actual
1507 '
1508
1509 cat >expected <<EOF
1510 hello.c:int main(int argc, const char **argv)
1511 hello.c:        /* char ?? */
1512
1513 hello_world:Hello_world
1514 EOF
1515
1516 test_expect_success 'grep --break' '
1517         git grep --break -e char -e lo_w hello.c hello_world >actual &&
1518         test_cmp expected actual
1519 '
1520
1521 cat >expected <<EOF
1522 hello.c:int main(int argc, const char **argv)
1523 hello.c-{
1524 --
1525 hello.c:        /* char ?? */
1526 hello.c-}
1527
1528 hello_world:Hello_world
1529 hello_world-HeLLo_world
1530 EOF
1531
1532 test_expect_success 'grep --break with context' '
1533         git grep --break -A1 -e char -e lo_w hello.c hello_world >actual &&
1534         test_cmp expected actual
1535 '
1536
1537 cat >expected <<EOF
1538 hello.c
1539 int main(int argc, const char **argv)
1540         /* char ?? */
1541 hello_world
1542 Hello_world
1543 EOF
1544
1545 test_expect_success 'grep --heading' '
1546         git grep --heading -e char -e lo_w hello.c hello_world >actual &&
1547         test_cmp expected actual
1548 '
1549
1550 cat >expected <<EOF
1551 <BOLD;GREEN>hello.c<RESET>
1552 4:int main(int argc, const <BLACK;BYELLOW>char<RESET> **argv)
1553 8:      /* <BLACK;BYELLOW>char<RESET> ?? */
1554
1555 <BOLD;GREEN>hello_world<RESET>
1556 3:Hel<BLACK;BYELLOW>lo_w<RESET>orld
1557 EOF
1558
1559 test_expect_success 'mimic ack-grep --group' '
1560         test_config color.grep.context          normal &&
1561         test_config color.grep.filename         "bold green" &&
1562         test_config color.grep.function         normal &&
1563         test_config color.grep.linenumber       normal &&
1564         test_config color.grep.match            "black yellow" &&
1565         test_config color.grep.selected         normal &&
1566         test_config color.grep.separator        normal &&
1567
1568         git grep --break --heading -n --color \
1569                 -e char -e lo_w hello.c hello_world |
1570         test_decode_color >actual &&
1571         test_cmp expected actual
1572 '
1573
1574 cat >expected <<EOF
1575 space: line with leading space1
1576 space: line with leading space2
1577 space: line with leading space3
1578 EOF
1579
1580 test_expect_success PCRE 'grep -E "^ "' '
1581         git grep -E "^ " space >actual &&
1582         test_cmp expected actual
1583 '
1584
1585 test_expect_success PCRE 'grep -P "^ "' '
1586         git grep -P "^ " space >actual &&
1587         test_cmp expected actual
1588 '
1589
1590 cat >expected <<EOF
1591 space-line without leading space1
1592 space: line <RED>with <RESET>leading space1
1593 space: line <RED>with <RESET>leading <RED>space2<RESET>
1594 space: line <RED>with <RESET>leading space3
1595 space:line without leading <RED>space2<RESET>
1596 EOF
1597
1598 test_expect_success 'grep --color -e A -e B with context' '
1599         test_config color.grep.context          normal &&
1600         test_config color.grep.filename         normal &&
1601         test_config color.grep.function         normal &&
1602         test_config color.grep.linenumber       normal &&
1603         test_config color.grep.matchContext     normal &&
1604         test_config color.grep.matchSelected    red &&
1605         test_config color.grep.selected         normal &&
1606         test_config color.grep.separator        normal &&
1607
1608         git grep --color=always -C2 -e "with " -e space2  space |
1609         test_decode_color >actual &&
1610         test_cmp expected actual
1611 '
1612
1613 cat >expected <<EOF
1614 space-line without leading space1
1615 space- line with leading space1
1616 space: line <RED>with <RESET>leading <RED>space2<RESET>
1617 space- line with leading space3
1618 space-line without leading space2
1619 EOF
1620
1621 test_expect_success 'grep --color -e A --and -e B with context' '
1622         test_config color.grep.context          normal &&
1623         test_config color.grep.filename         normal &&
1624         test_config color.grep.function         normal &&
1625         test_config color.grep.linenumber       normal &&
1626         test_config color.grep.matchContext     normal &&
1627         test_config color.grep.matchSelected    red &&
1628         test_config color.grep.selected         normal &&
1629         test_config color.grep.separator        normal &&
1630
1631         git grep --color=always -C2 -e "with " --and -e space2  space |
1632         test_decode_color >actual &&
1633         test_cmp expected actual
1634 '
1635
1636 cat >expected <<EOF
1637 space-line without leading space1
1638 space: line <RED>with <RESET>leading space1
1639 space- line with leading space2
1640 space: line <RED>with <RESET>leading space3
1641 space-line without leading space2
1642 EOF
1643
1644 test_expect_success 'grep --color -e A --and --not -e B with context' '
1645         test_config color.grep.context          normal &&
1646         test_config color.grep.filename         normal &&
1647         test_config color.grep.function         normal &&
1648         test_config color.grep.linenumber       normal &&
1649         test_config color.grep.matchContext     normal &&
1650         test_config color.grep.matchSelected    red &&
1651         test_config color.grep.selected         normal &&
1652         test_config color.grep.separator        normal &&
1653
1654         git grep --color=always -C2 -e "with " --and --not -e space2  space |
1655         test_decode_color >actual &&
1656         test_cmp expected actual
1657 '
1658
1659 cat >expected <<EOF
1660 hello.c-
1661 hello.c=int main(int argc, const char **argv)
1662 hello.c-{
1663 hello.c:        pr<RED>int<RESET>f("<RED>Hello<RESET> world.\n");
1664 hello.c-        return 0;
1665 hello.c-        /* char ?? */
1666 hello.c-}
1667 EOF
1668
1669 test_expect_success 'grep --color -e A --and -e B -p with context' '
1670         test_config color.grep.context          normal &&
1671         test_config color.grep.filename         normal &&
1672         test_config color.grep.function         normal &&
1673         test_config color.grep.linenumber       normal &&
1674         test_config color.grep.matchContext     normal &&
1675         test_config color.grep.matchSelected    red &&
1676         test_config color.grep.selected         normal &&
1677         test_config color.grep.separator        normal &&
1678
1679         git grep --color=always -p -C3 -e int --and -e Hello --no-index hello.c |
1680         test_decode_color >actual &&
1681         test_cmp expected actual
1682 '
1683
1684 test_expect_success 'grep can find things only in the work tree' '
1685         : >work-tree-only &&
1686         git add work-tree-only &&
1687         test_when_finished "git rm -f work-tree-only" &&
1688         echo "find in work tree" >work-tree-only &&
1689         git grep --quiet "find in work tree" &&
1690         test_must_fail git grep --quiet --cached "find in work tree" &&
1691         test_must_fail git grep --quiet "find in work tree" HEAD
1692 '
1693
1694 test_expect_success 'grep can find things only in the work tree (i-t-a)' '
1695         echo "intend to add this" >intend-to-add &&
1696         git add -N intend-to-add &&
1697         test_when_finished "git rm -f intend-to-add" &&
1698         git grep --quiet "intend to add this" &&
1699         test_must_fail git grep --quiet --cached "intend to add this" &&
1700         test_must_fail git grep --quiet "intend to add this" HEAD
1701 '
1702
1703 test_expect_success 'grep does not search work tree with assume unchanged' '
1704         echo "intend to add this" >intend-to-add &&
1705         git add -N intend-to-add &&
1706         git update-index --assume-unchanged intend-to-add &&
1707         test_when_finished "git rm -f intend-to-add" &&
1708         test_must_fail git grep --quiet "intend to add this" &&
1709         test_must_fail git grep --quiet --cached "intend to add this" &&
1710         test_must_fail git grep --quiet "intend to add this" HEAD
1711 '
1712
1713 test_expect_success 'grep can find things only in the index' '
1714         echo "only in the index" >cache-this &&
1715         git add cache-this &&
1716         rm cache-this &&
1717         test_when_finished "git rm --cached cache-this" &&
1718         test_must_fail git grep --quiet "only in the index" &&
1719         git grep --quiet --cached "only in the index" &&
1720         test_must_fail git grep --quiet "only in the index" HEAD
1721 '
1722
1723 test_expect_success 'grep does not report i-t-a with -L --cached' '
1724         echo "intend to add this" >intend-to-add &&
1725         git add -N intend-to-add &&
1726         test_when_finished "git rm -f intend-to-add" &&
1727         git ls-files | grep -v "^intend-to-add\$" >expected &&
1728         git grep -L --cached "nonexistent_string" >actual &&
1729         test_cmp expected actual
1730 '
1731
1732 test_expect_success 'grep does not report i-t-a and assume unchanged with -L' '
1733         echo "intend to add this" >intend-to-add-assume-unchanged &&
1734         git add -N intend-to-add-assume-unchanged &&
1735         test_when_finished "git rm -f intend-to-add-assume-unchanged" &&
1736         git update-index --assume-unchanged intend-to-add-assume-unchanged &&
1737         git ls-files | grep -v "^intend-to-add-assume-unchanged\$" >expected &&
1738         git grep -L "nonexistent_string" >actual &&
1739         test_cmp expected actual
1740 '
1741
1742 test_done