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