[thirdparty/git.git] / t / t7810-grep.sh

#!/bin/sh
#
# Copyright (c) 2006 Junio C Hamano
#

test_description='git grep various.
'

. ./test-lib.sh

cat >hello.c <<EOF
#include <stdio.h>
int main(int argc, const char **argv)
{
	printf("Hello world.\n");
	return 0;
	/* char ?? */
}
EOF

test_expect_success setup '
	{
		echo foo mmap bar
		echo foo_mmap bar
		echo foo_mmap bar mmap
		echo foo mmap bar_mmap
		echo foo_mmap bar mmap baz
	} >file &&
	{
		echo Hello world
		echo HeLLo world
		echo Hello_world
		echo HeLLo_world
	} >hello_world &&
	{
		echo aab
		echo a+b
		echo a\\+b
	} >ab &&
	echo vvv >v &&
	echo ww w >w &&
	echo x x xx x >x &&
	echo y yy >y &&
	echo zzz > z &&
	mkdir t &&
	echo test >t/t &&
	echo vvv >t/v &&
	mkdir t/a &&
	echo vvv >t/a/v &&
	git add . &&
	test_tick &&
	git commit -m initial
'

test_expect_success 'grep should not segfault with a bad input' '
	test_must_fail git grep "("
'

for H in HEAD ''
do
	case "$H" in
	HEAD)	HC='HEAD:' L='HEAD' ;;
	'')	HC= L='in working tree' ;;
	esac

	test_expect_success "grep -w $L" '
		{
			echo ${HC}file:1:foo mmap bar
			echo ${HC}file:3:foo_mmap bar mmap
			echo ${HC}file:4:foo mmap bar_mmap
			echo ${HC}file:5:foo_mmap bar mmap baz
		} >expected &&
		git -c grep.linenumber=false grep -n -w -e mmap $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L" '
		{
			echo ${HC}file:1:foo mmap bar
			echo ${HC}file:3:foo_mmap bar mmap
			echo ${HC}file:4:foo mmap bar_mmap
			echo ${HC}file:5:foo_mmap bar mmap baz
		} >expected &&
		git -c grep.linenumber=true grep -w -e mmap $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L" '
		{
			echo ${HC}file:foo mmap bar
			echo ${HC}file:foo_mmap bar mmap
			echo ${HC}file:foo mmap bar_mmap
			echo ${HC}file:foo_mmap bar mmap baz
		} >expected &&
		git -c grep.linenumber=true grep --no-line-number -w -e mmap $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L (w)" '
		: >expected &&
		test_must_fail git grep -n -w -e "^w" >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L (x)" '
		{
			echo ${HC}x:1:x x xx x
		} >expected &&
		git grep -n -w -e "x xx* x" $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L (y-1)" '
		{
			echo ${HC}y:1:y yy
		} >expected &&
		git grep -n -w -e "^y" $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -w $L (y-2)" '
		: >expected &&
		if git grep -n -w -e "^y y" $H >actual
		then
			echo should not have matched
			cat actual
			false
		else
			test_cmp expected actual
		fi
	'

	test_expect_success "grep -w $L (z)" '
		: >expected &&
		if git grep -n -w -e "^z" $H >actual
		then
			echo should not have matched
			cat actual
			false
		else
			test_cmp expected actual
		fi
	'

	test_expect_success "grep $L (t-1)" '
		echo "${HC}t/t:1:test" >expected &&
		git grep -n -e test $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep $L (t-2)" '
		echo "${HC}t:1:test" >expected &&
		(
			cd t &&
			git grep -n -e test $H
		) >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep $L (t-3)" '
		echo "${HC}t/t:1:test" >expected &&
		(
			cd t &&
			git grep --full-name -n -e test $H
		) >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep -c $L (no /dev/null)" '
		! git grep -c test $H | grep /dev/null
        '

	test_expect_success "grep --max-depth -1 $L" '
		{
			echo ${HC}t/a/v:1:vvv
			echo ${HC}t/v:1:vvv
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth -1 -n -e vvv $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 0 $L" '
		{
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth 0 -n -e vvv $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 0 -- '*' $L" '
		{
			echo ${HC}t/a/v:1:vvv
			echo ${HC}t/v:1:vvv
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth 0 -n -e vvv $H -- "*" >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 1 $L" '
		{
			echo ${HC}t/v:1:vvv
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth 1 -n -e vvv $H >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 0 -- t $L" '
		{
			echo ${HC}t/v:1:vvv
		} >expected &&
		git grep --max-depth 0 -n -e vvv $H -- t >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 0 -- . t $L" '
		{
			echo ${HC}t/v:1:vvv
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth 0 -n -e vvv $H -- . t >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep --max-depth 0 -- t . $L" '
		{
			echo ${HC}t/v:1:vvv
			echo ${HC}v:1:vvv
		} >expected &&
		git grep --max-depth 0 -n -e vvv $H -- t . >actual &&
		test_cmp expected actual
	'
	test_expect_success "grep $L with grep.extendedRegexp=false" '
		echo "ab:a+b" >expected &&
		git -c grep.extendedRegexp=false grep "a+b" >actual &&
		test_cmp expected actual
	'

	test_expect_success "grep $L with grep.extendedRegexp=true" '
		echo "ab:aab" >expected &&
		git -c grep.extendedRegexp=true grep "a+b" >actual &&
		test_cmp expected actual
	'
done

cat >expected <<EOF
file:foo mmap bar_mmap
EOF

test_expect_success 'grep -e A --and -e B' '
	git grep -e "foo mmap" --and -e bar_mmap >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
file:foo_mmap bar mmap
file:foo_mmap bar mmap baz
EOF


test_expect_success 'grep ( -e A --or -e B ) --and -e B' '
	git grep \( -e foo_ --or -e baz \) \
		--and -e " mmap" >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
file:foo mmap bar
EOF

test_expect_success 'grep -e A --and --not -e B' '
	git grep -e "foo mmap" --and --not -e bar_mmap >actual &&
	test_cmp expected actual
'

test_expect_success 'grep should ignore GREP_OPTIONS' '
	GREP_OPTIONS=-v git grep " mmap bar\$" >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -f, non-existent file' '
	test_must_fail git grep -f patterns
'

cat >expected <<EOF
file:foo mmap bar
file:foo_mmap bar
file:foo_mmap bar mmap
file:foo mmap bar_mmap
file:foo_mmap bar mmap baz
EOF

cat >pattern <<EOF
mmap
EOF

test_expect_success 'grep -f, one pattern' '
	git grep -f pattern >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
file:foo mmap bar
file:foo_mmap bar
file:foo_mmap bar mmap
file:foo mmap bar_mmap
file:foo_mmap bar mmap baz
t/a/v:vvv
t/v:vvv
v:vvv
EOF

cat >patterns <<EOF
mmap
vvv
EOF

test_expect_success 'grep -f, multiple patterns' '
	git grep -f patterns >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
file:foo mmap bar
file:foo_mmap bar
file:foo_mmap bar mmap
file:foo mmap bar_mmap
file:foo_mmap bar mmap baz
t/a/v:vvv
t/v:vvv
v:vvv
EOF

cat >patterns <<EOF

mmap

vvv

EOF

test_expect_success 'grep -f, ignore empty lines' '
	git grep -f patterns >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -f, ignore empty lines, read patterns from stdin' '
	git grep -f - <patterns >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
y:y yy
--
z:zzz
EOF

test_expect_success 'grep -q, silently report matches' '
	>empty &&
	git grep -q mmap >actual &&
	test_cmp empty actual &&
	test_must_fail git grep -q qfwfq >actual &&
	test_cmp empty actual
'

# Create 1024 file names that sort between "y" and "z" to make sure
# the two files are handled by different calls to an external grep.
# This depends on MAXARGS in builtin-grep.c being 1024 or less.
c32="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v"
test_expect_success 'grep -C1, hunk mark between files' '
	for a in $c32; do for b in $c32; do : >y-$a$b; done; done &&
	git add y-?? &&
	git grep -C1 "^[yz]" >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -C1 hunk mark between files' '
	git grep -C1 "^[yz]" >actual &&
	test_cmp expected actual
'

test_expect_success 'log grep setup' '
	echo a >>file &&
	test_tick &&
	GIT_AUTHOR_NAME="With * Asterisk" \
	GIT_AUTHOR_EMAIL="xyzzy@frotz.com" \
	git commit -a -m "second" &&

	echo a >>file &&
	test_tick &&
	git commit -a -m "third" &&

	echo a >>file &&
	test_tick &&
	GIT_AUTHOR_NAME="Night Fall" \
	GIT_AUTHOR_EMAIL="nitfol@frobozz.com" \
	git commit -a -m "fourth"
'

test_expect_success 'log grep (1)' '
	git log --author=author --pretty=tformat:%s >actual &&
	( echo third ; echo initial ) >expect &&
	test_cmp expect actual
'

test_expect_success 'log grep (2)' '
	git log --author=" * " -F --pretty=tformat:%s >actual &&
	( echo second ) >expect &&
	test_cmp expect actual
'

test_expect_success 'log grep (3)' '
	git log --author="^A U" --pretty=tformat:%s >actual &&
	( echo third ; echo initial ) >expect &&
	test_cmp expect actual
'

test_expect_success 'log grep (4)' '
	git log --author="frotz\.com>$" --pretty=tformat:%s >actual &&
	( echo second ) >expect &&
	test_cmp expect actual
'

test_expect_success 'log grep (5)' '
	git log --author=Thor -F --pretty=tformat:%s >actual &&
	( echo third ; echo initial ) >expect &&
	test_cmp expect actual
'

test_expect_success 'log grep (6)' '
	git log --author=-0700  --pretty=tformat:%s >actual &&
	>expect &&
	test_cmp expect actual
'

test_expect_success 'log --grep --author implicitly uses all-match' '
	# grep matches initial and second but not third
	# author matches only initial and third
	git log --author="A U Thor" --grep=s --grep=l --format=%s >actual &&
	echo initial >expect &&
	test_cmp expect actual
'

test_expect_success 'log with multiple --author uses union' '
	git log --author="Thor" --author="Aster" --format=%s >actual &&
	{
	    echo third && echo second && echo initial
	} >expect &&
	test_cmp expect actual
'

test_expect_success 'log with --grep and multiple --author uses all-match' '
	git log --author="Thor" --author="Night" --grep=i --format=%s >actual &&
	{
	    echo third && echo initial
	} >expect &&
	test_cmp expect actual
'

test_expect_success 'log with --grep and multiple --author uses all-match' '
	git log --author="Thor" --author="Night" --grep=q --format=%s >actual &&
	>expect &&
	test_cmp expect actual
'

test_expect_success 'grep with CE_VALID file' '
	git update-index --assume-unchanged t/t &&
	rm t/t &&
	test "$(git grep test)" = "t/t:test" &&
	git update-index --no-assume-unchanged t/t &&
	git checkout t/t
'

cat >expected <<EOF
hello.c=#include <stdio.h>
hello.c:	return 0;
EOF

test_expect_success 'grep -p with userdiff' '
	git config diff.custom.funcname "^#" &&
	echo "hello.c diff=custom" >.gitattributes &&
	git grep -p return >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
hello.c=int main(int argc, const char **argv)
hello.c:	return 0;
EOF

test_expect_success 'grep -p' '
	rm -f .gitattributes &&
	git grep -p return >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
hello.c-#include <stdio.h>
hello.c=int main(int argc, const char **argv)
hello.c-{
hello.c-	printf("Hello world.\n");
hello.c:	return 0;
EOF

test_expect_success 'grep -p -B5' '
	git grep -p -B5 return >actual &&
	test_cmp expected actual
'

test_expect_success 'grep from a subdirectory to search wider area (1)' '
	mkdir -p s &&
	(
		cd s && git grep "x x x" ..
	)
'

test_expect_success 'grep from a subdirectory to search wider area (2)' '
	mkdir -p s &&
	(
		cd s || exit 1
		( git grep xxyyzz .. >out ; echo $? >status )
		! test -s out &&
		test 1 = $(cat status)
	)
'

cat >expected <<EOF
hello.c:int main(int argc, const char **argv)
EOF

test_expect_success 'grep -Fi' '
	git grep -Fi "CHAR *" >actual &&
	test_cmp expected actual
'

test_expect_success 'outside of git repository' '
	rm -fr non &&
	mkdir -p non/git/sub &&
	echo hello >non/git/file1 &&
	echo world >non/git/sub/file2 &&
	echo ".*o*" >non/git/.gitignore &&
	{
		echo file1:hello &&
		echo sub/file2:world
	} >non/expect.full &&
	echo file2:world >non/expect.sub &&
	(
		GIT_CEILING_DIRECTORIES="$(pwd)/non/git" &&
		export GIT_CEILING_DIRECTORIES &&
		cd non/git &&
		test_must_fail git grep o &&
		git grep --no-index o >../actual.full &&
		test_cmp ../expect.full ../actual.full
		cd sub &&
		test_must_fail git grep o &&
		git grep --no-index o >../../actual.sub &&
		test_cmp ../../expect.sub ../../actual.sub
	)
'

test_expect_success 'inside git repository but with --no-index' '
	rm -fr is &&
	mkdir -p is/git/sub &&
	echo hello >is/git/file1 &&
	echo world >is/git/sub/file2 &&
	echo ".*o*" >is/git/.gitignore &&
	{
		echo file1:hello &&
		echo sub/file2:world
	} >is/expect.full &&
	: >is/expect.empty &&
	echo file2:world >is/expect.sub &&
	(
		cd is/git &&
		git init &&
		test_must_fail git grep o >../actual.full &&
		test_cmp ../expect.empty ../actual.full &&
		git grep --no-index o >../actual.full &&
		test_cmp ../expect.full ../actual.full &&
		cd sub &&
		test_must_fail git grep o >../../actual.sub &&
		test_cmp ../../expect.empty ../../actual.sub &&
		git grep --no-index o >../../actual.sub &&
		test_cmp ../../expect.sub ../../actual.sub
	)
'

test_expect_success 'setup double-dash tests' '
cat >double-dash <<EOF &&
--
->
other
EOF
git add double-dash
'

cat >expected <<EOF
double-dash:->
EOF
test_expect_success 'grep -- pattern' '
	git grep -- "->" >actual &&
	test_cmp expected actual
'
test_expect_success 'grep -- pattern -- pathspec' '
	git grep -- "->" -- double-dash >actual &&
	test_cmp expected actual
'
test_expect_success 'grep -e pattern -- path' '
	git grep -e "->" -- double-dash >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
double-dash:--
EOF
test_expect_success 'grep -e -- -- path' '
	git grep -e -- -- double-dash >actual &&
	test_cmp expected actual
'

cat >expected <<EOF
hello.c:int main(int argc, const char **argv)
hello.c:	printf("Hello world.\n");
EOF

test_expect_success LIBPCRE 'grep --perl-regexp pattern' '
	git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	test_cmp expected actual
'

test_expect_success LIBPCRE 'grep -P pattern' '
	git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	test_cmp expected actual
'

test_expect_success 'grep pattern with grep.extendedRegexp=true' '
	:>empty &&
	test_must_fail git -c grep.extendedregexp=true \
		grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	test_cmp empty actual
'

test_expect_success LIBPCRE 'grep -P pattern with grep.extendedRegexp=true' '
	git -c grep.extendedregexp=true \
		grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	test_cmp expected actual
'

test_expect_success LIBPCRE 'grep -P -v pattern' '
	{
		echo ab:a+b
		echo ab:a\\+b
	} >expected &&
	git grep -P -v "aab" ab >actual &&
	test_cmp expected actual
'

test_expect_success LIBPCRE 'grep -P -i pattern' '
	{
		echo "hello.c:	printf(\"Hello world.\n\");"
	} >expected &&
	git grep -P -i "PRINTF\([^\d]+\)" hello.c >actual &&
	test_cmp expected actual
'

test_expect_success LIBPCRE 'grep -P -w pattern' '
	{
		echo "hello_world:Hello world"
		echo "hello_world:HeLLo world"
	} >expected &&
	git grep -P -w "He((?i)ll)o" hello_world >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -G invalidpattern properly dies ' '
	test_must_fail git grep -G "a["
'

test_expect_success 'grep -E invalidpattern properly dies ' '
	test_must_fail git grep -E "a["
'

test_expect_success LIBPCRE 'grep -P invalidpattern properly dies ' '
	test_must_fail git grep -P "a["
'

test_expect_success 'grep -F -E -G pattern' '
	echo ab:a+b >expected &&
	git grep -F -E -G a+b >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -F -G -E pattern' '
	echo ab:aab >expected &&
	git grep -F -G -E a+b >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -E -F -G pattern' '
	echo ab:aab >expected &&
	git grep -E -F -G a\\+b >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -E -G -F pattern' '
	echo ab:a\\+b >expected &&
	git grep -E -G -F a\\+b >actual &&
	test_cmp expected actual
'

test_expect_success 'grep -G -F -E pattern' '
	echo ab:a+b >expected &&
	git grep -G -F -E a\\+b >actual &&
	test_cmp expected actual
'

test_expect_success LIBPCRE 'grep -E -G -F -P pattern' '
	echo ab:a+b >expected &&
	git grep -E -G -F -P a\\+b >actual &&
	test_cmp expected actual
'

test_done
Commit	Line	Data
f25b7939 JH	1	#!/bin/sh
	2	#
	3	# Copyright (c) 2006 Junio C Hamano
	4	#
	5
0d042fec	6	test_description='git grep various.
f25b7939 JH	7	'
	8
	9	. ./test-lib.sh
	10
2944e4e6 RS	11	cat >hello.c <<EOF
	12	#include <stdio.h>
	13	int main(int argc, const char **argv)
	14	{
	15	printf("Hello world.\n");
	16	return 0;
5183bf67	17	/* char ?? */
2944e4e6 RS	18	}
	19	EOF
	20
f25b7939 JH	21	test_expect_success setup '
	22	{
	23	echo foo mmap bar
	24	echo foo_mmap bar
	25	echo foo_mmap bar mmap
	26	echo foo mmap bar_mmap
	27	echo foo_mmap bar mmap baz
	28	} >file &&
8f852ce6 MK	29	{
	30	echo Hello world
	31	echo HeLLo world
	32	echo Hello_world
	33	echo HeLLo_world
	34	} >hello_world &&
f556e4af MK	35	{
	36	echo aab
	37	echo a+b
	38	echo a\\+b
	39	} >ab &&
a91f453f	40	echo vvv >v &&
dbb6a4ad	41	echo ww w >w &&
f25b7939 JH	42	echo x x xx x >x &&
	43	echo y yy >y &&
	44	echo zzz > z &&
0d042fec JH	45	mkdir t &&
0d042fec JH	46	echo test >t/t &&
a91f453f MK	47	echo vvv >t/v &&
	48	mkdir t/a &&
	49	echo vvv >t/a/v &&
	50	git add . &&
a4d7d2c6	51	test_tick &&
f25b7939 JH	52	git commit -m initial
	53	'
	54
c922b01f LT	55	test_expect_success 'grep should not segfault with a bad input' '
	56	test_must_fail git grep "("
	57	'
	58
f25b7939 JH	59	for H in HEAD ''
	60	do
	61	case "$H" in
	62	HEAD) HC='HEAD:' L='HEAD' ;;
	63	'') HC= L='in working tree' ;;
	64	esac
	65
	66	test_expect_success "grep -w $L" '
	67	{
	68	echo ${HC}file:1:foo mmap bar
	69	echo ${HC}file:3:foo_mmap bar mmap
	70	echo ${HC}file:4:foo mmap bar_mmap
	71	echo ${HC}file:5:foo_mmap bar mmap baz
	72	} >expected &&
b22520a3 JR	73	git -c grep.linenumber=false grep -n -w -e mmap $H >actual &&
	74	test_cmp expected actual
	75	'
	76
	77	test_expect_success "grep -w $L" '
	78	{
	79	echo ${HC}file:1:foo mmap bar
	80	echo ${HC}file:3:foo_mmap bar mmap
	81	echo ${HC}file:4:foo mmap bar_mmap
	82	echo ${HC}file:5:foo_mmap bar mmap baz
	83	} >expected &&
	84	git -c grep.linenumber=true grep -w -e mmap $H >actual &&
	85	test_cmp expected actual
	86	'
	87
	88	test_expect_success "grep -w $L" '
	89	{
	90	echo ${HC}file:foo mmap bar
	91	echo ${HC}file:foo_mmap bar mmap
	92	echo ${HC}file:foo mmap bar_mmap
	93	echo ${HC}file:foo_mmap bar mmap baz
	94	} >expected &&
	95	git -c grep.linenumber=true grep --no-line-number -w -e mmap $H >actual &&
4fdf71be	96	test_cmp expected actual
f25b7939 JH	97	'
f25b7939 JH	98
dbb6a4ad RS	99	test_expect_success "grep -w $L (w)" '
dbb6a4ad RS	100	: >expected &&
ce14e0b2	101	test_must_fail git grep -n -w -e "^w" >actual &&
dbb6a4ad RS	102	test_cmp expected actual
	103	'
	104
f25b7939 JH	105	test_expect_success "grep -w $L (x)" '
	106	{
	107	echo ${HC}x:1:x x xx x
	108	} >expected &&
	109	git grep -n -w -e "x xx* x" $H >actual &&
4fdf71be	110	test_cmp expected actual
f25b7939 JH	111	'
	112
	113	test_expect_success "grep -w $L (y-1)" '
	114	{
	115	echo ${HC}y:1:y yy
	116	} >expected &&
	117	git grep -n -w -e "^y" $H >actual &&
4fdf71be	118	test_cmp expected actual
f25b7939 JH	119	'
	120
	121	test_expect_success "grep -w $L (y-2)" '
	122	: >expected &&
	123	if git grep -n -w -e "^y y" $H >actual
	124	then
	125	echo should not have matched
	126	cat actual
	127	false
	128	else
4fdf71be	129	test_cmp expected actual
f25b7939 JH	130	fi
	131	'
	132
	133	test_expect_success "grep -w $L (z)" '
	134	: >expected &&
	135	if git grep -n -w -e "^z" $H >actual
	136	then
	137	echo should not have matched
	138	cat actual
	139	false
	140	else
4fdf71be	141	test_cmp expected actual
f25b7939 JH	142	fi
f25b7939 JH	143	'
0d042fec JH	144
	145	test_expect_success "grep $L (t-1)" '
	146	echo "${HC}t/t:1:test" >expected &&
	147	git grep -n -e test $H >actual &&
4fdf71be	148	test_cmp expected actual
0d042fec JH	149	'
	150
	151	test_expect_success "grep $L (t-2)" '
	152	echo "${HC}t:1:test" >expected &&
	153	(
	154	cd t &&
	155	git grep -n -e test $H
	156	) >actual &&
4fdf71be	157	test_cmp expected actual
0d042fec JH	158	'
	159
	160	test_expect_success "grep $L (t-3)" '
	161	echo "${HC}t/t:1:test" >expected &&
	162	(
	163	cd t &&
	164	git grep --full-name -n -e test $H
	165	) >actual &&
4fdf71be	166	test_cmp expected actual
0d042fec JH	167	'
0d042fec JH	168
41ac414e	169	test_expect_success "grep -c $L (no /dev/null)" '
87539416	170	! git grep -c test $H \| grep /dev/null
d99ebf08 JH	171	'
d99ebf08 JH	172
a91f453f MK	173	test_expect_success "grep --max-depth -1 $L" '
	174	{
	175	echo ${HC}t/a/v:1:vvv
	176	echo ${HC}t/v:1:vvv
	177	echo ${HC}v:1:vvv
	178	} >expected &&
	179	git grep --max-depth -1 -n -e vvv $H >actual &&
	180	test_cmp expected actual
	181	'
	182
	183	test_expect_success "grep --max-depth 0 $L" '
	184	{
	185	echo ${HC}v:1:vvv
	186	} >expected &&
	187	git grep --max-depth 0 -n -e vvv $H >actual &&
	188	test_cmp expected actual
	189	'
	190
	191	test_expect_success "grep --max-depth 0 -- '*' $L" '
	192	{
	193	echo ${HC}t/a/v:1:vvv
	194	echo ${HC}t/v:1:vvv
	195	echo ${HC}v:1:vvv
	196	} >expected &&
	197	git grep --max-depth 0 -n -e vvv $H -- "*" >actual &&
	198	test_cmp expected actual
	199	'
	200
	201	test_expect_success "grep --max-depth 1 $L" '
	202	{
	203	echo ${HC}t/v:1:vvv
	204	echo ${HC}v:1:vvv
	205	} >expected &&
	206	git grep --max-depth 1 -n -e vvv $H >actual &&
	207	test_cmp expected actual
	208	'
	209
	210	test_expect_success "grep --max-depth 0 -- t $L" '
	211	{
	212	echo ${HC}t/v:1:vvv
	213	} >expected &&
	214	git grep --max-depth 0 -n -e vvv $H -- t >actual &&
	215	test_cmp expected actual
	216	'
	217
b31f6880 NTND	218	test_expect_success "grep --max-depth 0 -- . t $L" '
	219	{
	220	echo ${HC}t/v:1:vvv
	221	echo ${HC}v:1:vvv
	222	} >expected &&
	223	git grep --max-depth 0 -n -e vvv $H -- . t >actual &&
	224	test_cmp expected actual
	225	'
	226
	227	test_expect_success "grep --max-depth 0 -- t . $L" '
	228	{
	229	echo ${HC}t/v:1:vvv
	230	echo ${HC}v:1:vvv
	231	} >expected &&
	232	git grep --max-depth 0 -n -e vvv $H -- t . >actual &&
	233	test_cmp expected actual
	234	'
f556e4af MK	235	test_expect_success "grep $L with grep.extendedRegexp=false" '
	236	echo "ab:a+b" >expected &&
	237	git -c grep.extendedRegexp=false grep "a+b" >actual &&
	238	test_cmp expected actual
	239	'
b31f6880	240
f556e4af MK	241	test_expect_success "grep $L with grep.extendedRegexp=true" '
	242	echo "ab:aab" >expected &&
	243	git -c grep.extendedRegexp=true grep "a+b" >actual &&
	244	test_cmp expected actual
	245	'
f25b7939 JH	246	done
f25b7939 JH	247
0f705046 TR	248	cat >expected <<EOF
	249	file:foo mmap bar_mmap
	250	EOF
	251
	252	test_expect_success 'grep -e A --and -e B' '
	253	git grep -e "foo mmap" --and -e bar_mmap >actual &&
	254	test_cmp expected actual
	255	'
	256
	257	cat >expected <<EOF
	258	file:foo_mmap bar mmap
	259	file:foo_mmap bar mmap baz
	260	EOF
	261
	262
	263	test_expect_success 'grep ( -e A --or -e B ) --and -e B' '
	264	git grep \( -e foo_ --or -e baz \) \
	265	--and -e " mmap" >actual &&
	266	test_cmp expected actual
	267	'
	268
	269	cat >expected <<EOF
	270	file:foo mmap bar
	271	EOF
	272
	273	test_expect_success 'grep -e A --and --not -e B' '
	274	git grep -e "foo mmap" --and --not -e bar_mmap >actual &&
	275	test_cmp expected actual
	276	'
	277
b4827599 RS	278	test_expect_success 'grep should ignore GREP_OPTIONS' '
	279	GREP_OPTIONS=-v git grep " mmap bar\$" >actual &&
	280	test_cmp expected actual
	281	'
	282
cfe370c6 MK	283	test_expect_success 'grep -f, non-existent file' '
	284	test_must_fail git grep -f patterns
	285	'
	286
	287	cat >expected <<EOF
	288	file:foo mmap bar
	289	file:foo_mmap bar
	290	file:foo_mmap bar mmap
	291	file:foo mmap bar_mmap
	292	file:foo_mmap bar mmap baz
	293	EOF
	294
	295	cat >pattern <<EOF
	296	mmap
	297	EOF
	298
	299	test_expect_success 'grep -f, one pattern' '
	300	git grep -f pattern >actual &&
	301	test_cmp expected actual
	302	'
	303
	304	cat >expected <<EOF
	305	file:foo mmap bar
	306	file:foo_mmap bar
	307	file:foo_mmap bar mmap
	308	file:foo mmap bar_mmap
	309	file:foo_mmap bar mmap baz
	310	t/a/v:vvv
	311	t/v:vvv
	312	v:vvv
	313	EOF
	314
	315	cat >patterns <<EOF
	316	mmap
	317	vvv
	318	EOF
	319
	320	test_expect_success 'grep -f, multiple patterns' '
	321	git grep -f patterns >actual &&
	322	test_cmp expected actual
	323	'
	324
	325	cat >expected <<EOF
	326	file:foo mmap bar
	327	file:foo_mmap bar
	328	file:foo_mmap bar mmap
	329	file:foo mmap bar_mmap
	330	file:foo_mmap bar mmap baz
	331	t/a/v:vvv
	332	t/v:vvv
	333	v:vvv
	334	EOF
	335
	336	cat >patterns <<EOF
	337
	338	mmap
	339
	340	vvv
	341
	342	EOF
	343
	344	test_expect_success 'grep -f, ignore empty lines' '
	345	git grep -f patterns >actual &&
	346	test_cmp expected actual
347	'
348
c41dd2fd RS	349	test_expect_success 'grep -f, ignore empty lines, read patterns from stdin' '
	350	git grep -f - <patterns >actual &&
	351	test_cmp expected actual
	352	'
	353
046802d0 RS	354	cat >expected <<EOF
	355	y:y yy
	356	--
	357	z:zzz
	358	EOF
	359
4ff61c21 JH	360	test_expect_success 'grep -q, silently report matches' '
	361	>empty &&
	362	git grep -q mmap >actual &&
	363	test_cmp empty actual &&
	364	test_must_fail git grep -q qfwfq >actual &&
	365	test_cmp empty actual
	366	'
	367
046802d0 RS	368	# Create 1024 file names that sort between "y" and "z" to make sure
	369	# the two files are handled by different calls to an external grep.
	370	# This depends on MAXARGS in builtin-grep.c being 1024 or less.
	371	c32="0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v"
	372	test_expect_success 'grep -C1, hunk mark between files' '
	373	for a in $c32; do for b in $c32; do : >y-$a$b; done; done &&
	374	git add y-?? &&
	375	git grep -C1 "^[yz]" >actual &&
	376	test_cmp expected actual
	377	'
	378
bbc09c22 JH	379	test_expect_success 'grep -C1 hunk mark between files' '
bbc09c22 JH	380	git grep -C1 "^[yz]" >actual &&
046802d0 RS	381	test_cmp expected actual
	382	'
	383
a4d7d2c6 JH	384	test_expect_success 'log grep setup' '
	385	echo a >>file &&
	386	test_tick &&
	387	GIT_AUTHOR_NAME="With * Asterisk" \
	388	GIT_AUTHOR_EMAIL="xyzzy@frotz.com" \
	389	git commit -a -m "second" &&
	390
	391	echo a >>file &&
	392	test_tick &&
5aaeb733	393	git commit -a -m "third" &&
a4d7d2c6	394
5aaeb733 JH	395	echo a >>file &&
	396	test_tick &&
	397	GIT_AUTHOR_NAME="Night Fall" \
	398	GIT_AUTHOR_EMAIL="nitfol@frobozz.com" \
	399	git commit -a -m "fourth"
a4d7d2c6 JH	400	'
	401
	402	test_expect_success 'log grep (1)' '
	403	git log --author=author --pretty=tformat:%s >actual &&
	404	( echo third ; echo initial ) >expect &&
	405	test_cmp expect actual
	406	'
	407
	408	test_expect_success 'log grep (2)' '
	409	git log --author=" * " -F --pretty=tformat:%s >actual &&
	410	( echo second ) >expect &&
	411	test_cmp expect actual
	412	'
	413
	414	test_expect_success 'log grep (3)' '
	415	git log --author="^A U" --pretty=tformat:%s >actual &&
	416	( echo third ; echo initial ) >expect &&
	417	test_cmp expect actual
	418	'
	419
	420	test_expect_success 'log grep (4)' '
	421	git log --author="frotz\.com>$" --pretty=tformat:%s >actual &&
	422	( echo second ) >expect &&
	423	test_cmp expect actual
	424	'
	425
	426	test_expect_success 'log grep (5)' '
80235ba7	427	git log --author=Thor -F --pretty=tformat:%s >actual &&
a4d7d2c6 JH	428	( echo third ; echo initial ) >expect &&
	429	test_cmp expect actual
	430	'
	431
	432	test_expect_success 'log grep (6)' '
	433	git log --author=-0700 --pretty=tformat:%s >actual &&
	434	>expect &&
	435	test_cmp expect actual
57d43466	436	'
a4d7d2c6	437
80235ba7 JH	438	test_expect_success 'log --grep --author implicitly uses all-match' '
	439	# grep matches initial and second but not third
	440	# author matches only initial and third
	441	git log --author="A U Thor" --grep=s --grep=l --format=%s >actual &&
	442	echo initial >expect &&
	443	test_cmp expect actual
	444	'
	445
5aaeb733 JH	446	test_expect_success 'log with multiple --author uses union' '
	447	git log --author="Thor" --author="Aster" --format=%s >actual &&
	448	{
	449	echo third && echo second && echo initial
	450	} >expect &&
	451	test_cmp expect actual
	452	'
	453
	454	test_expect_success 'log with --grep and multiple --author uses all-match' '
	455	git log --author="Thor" --author="Night" --grep=i --format=%s >actual &&
	456	{
	457	echo third && echo initial
	458	} >expect &&
	459	test_cmp expect actual
	460	'
	461
	462	test_expect_success 'log with --grep and multiple --author uses all-match' '
	463	git log --author="Thor" --author="Night" --grep=q --format=%s >actual &&
	464	>expect &&
	465	test_cmp expect actual
	466	'
	467
57d43466 NTND	468	test_expect_success 'grep with CE_VALID file' '
	469	git update-index --assume-unchanged t/t &&
	470	rm t/t &&
bbc09c22	471	test "$(git grep test)" = "t/t:test" &&
57d43466 NTND	472	git update-index --no-assume-unchanged t/t &&
57d43466 NTND	473	git checkout t/t
a4d7d2c6 JH	474	'
a4d7d2c6 JH	475
60ecac98 RS	476	cat >expected <<EOF
	477	hello.c=#include <stdio.h>
	478	hello.c: return 0;
	479	EOF
	480
	481	test_expect_success 'grep -p with userdiff' '
	482	git config diff.custom.funcname "^#" &&
	483	echo "hello.c diff=custom" >.gitattributes &&
	484	git grep -p return >actual &&
	485	test_cmp expected actual
	486	'
	487
2944e4e6 RS	488	cat >expected <<EOF
	489	hello.c=int main(int argc, const char **argv)
	490	hello.c: return 0;
	491	EOF
	492
	493	test_expect_success 'grep -p' '
60ecac98	494	rm -f .gitattributes &&
2944e4e6 RS	495	git grep -p return >actual &&
	496	test_cmp expected actual
	497	'
	498
	499	cat >expected <<EOF
	500	hello.c-#include <stdio.h>
	501	hello.c=int main(int argc, const char **argv)
	502	hello.c-{
	503	hello.c- printf("Hello world.\n");
	504	hello.c: return 0;
	505	EOF
	506
	507	test_expect_success 'grep -p -B5' '
	508	git grep -p -B5 return >actual &&
	509	test_cmp expected actual
	510	'
	511
493b7a08 CB	512	test_expect_success 'grep from a subdirectory to search wider area (1)' '
	513	mkdir -p s &&
	514	(
	515	cd s && git grep "x x x" ..
	516	)
	517	'
	518
	519	test_expect_success 'grep from a subdirectory to search wider area (2)' '
	520	mkdir -p s &&
	521	(
	522	cd s \|\| exit 1
	523	( git grep xxyyzz .. >out ; echo $? >status )
	524	! test -s out &&
	525	test 1 = $(cat status)
	526	)
	527	'
	528
5183bf67 BC	529	cat >expected <<EOF
	530	hello.c:int main(int argc, const char **argv)
	531	EOF
	532
	533	test_expect_success 'grep -Fi' '
	534	git grep -Fi "CHAR *" >actual &&
	535	test_cmp expected actual
	536	'
	537
59332d13 JH	538	test_expect_success 'outside of git repository' '
	539	rm -fr non &&
	540	mkdir -p non/git/sub &&
	541	echo hello >non/git/file1 &&
	542	echo world >non/git/sub/file2 &&
	543	echo ".o" >non/git/.gitignore &&
	544	{
	545	echo file1:hello &&
	546	echo sub/file2:world
	547	} >non/expect.full &&
a48fcd83	548	echo file2:world >non/expect.sub &&
59332d13 JH	549	(
	550	GIT_CEILING_DIRECTORIES="$(pwd)/non/git" &&
	551	export GIT_CEILING_DIRECTORIES &&
	552	cd non/git &&
	553	test_must_fail git grep o &&
	554	git grep --no-index o >../actual.full &&
	555	test_cmp ../expect.full ../actual.full
	556	cd sub &&
	557	test_must_fail git grep o &&
	558	git grep --no-index o >../../actual.sub &&
	559	test_cmp ../../expect.sub ../../actual.sub
	560	)
	561	'
	562
	563	test_expect_success 'inside git repository but with --no-index' '
	564	rm -fr is &&
	565	mkdir -p is/git/sub &&
	566	echo hello >is/git/file1 &&
	567	echo world >is/git/sub/file2 &&
	568	echo ".o" >is/git/.gitignore &&
	569	{
	570	echo file1:hello &&
	571	echo sub/file2:world
	572	} >is/expect.full &&
	573	: >is/expect.empty &&
a48fcd83	574	echo file2:world >is/expect.sub &&
59332d13 JH	575	(
	576	cd is/git &&
	577	git init &&
	578	test_must_fail git grep o >../actual.full &&
	579	test_cmp ../expect.empty ../actual.full &&
	580	git grep --no-index o >../actual.full &&
	581	test_cmp ../expect.full ../actual.full &&
	582	cd sub &&
	583	test_must_fail git grep o >../../actual.sub &&
	584	test_cmp ../../expect.empty ../../actual.sub &&
	585	git grep --no-index o >../../actual.sub &&
	586	test_cmp ../../expect.sub ../../actual.sub
	587	)
	588	'
	589
1123c67c JK	590	test_expect_success 'setup double-dash tests' '
	591	cat >double-dash <<EOF &&
	592	--
	593	->
	594	other
	595	EOF
	596	git add double-dash
	597	'
	598
	599	cat >expected <<EOF
	600	double-dash:->
	601	EOF
	602	test_expect_success 'grep -- pattern' '
	603	git grep -- "->" >actual &&
	604	test_cmp expected actual
	605	'
	606	test_expect_success 'grep -- pattern -- pathspec' '
	607	git grep -- "->" -- double-dash >actual &&
	608	test_cmp expected actual
	609	'
	610	test_expect_success 'grep -e pattern -- path' '
	611	git grep -e "->" -- double-dash >actual &&
	612	test_cmp expected actual
	613	'
	614
	615	cat >expected <<EOF
	616	double-dash:--
	617	EOF
	618	test_expect_success 'grep -e -- -- path' '
	619	git grep -e -- -- double-dash >actual &&
	620	test_cmp expected actual
	621	'
	622
8f852ce6 MK	623	cat >expected <<EOF
	624	hello.c:int main(int argc, const char **argv)
	625	hello.c: printf("Hello world.\n");
	626	EOF
	627
	628	test_expect_success LIBPCRE 'grep --perl-regexp pattern' '
	629	git grep --perl-regexp "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	630	test_cmp expected actual
	631	'
	632
	633	test_expect_success LIBPCRE 'grep -P pattern' '
	634	git grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	635	test_cmp expected actual
	636	'
	637
f556e4af MK	638	test_expect_success 'grep pattern with grep.extendedRegexp=true' '
	639	:>empty &&
	640	test_must_fail git -c grep.extendedregexp=true \
	641	grep "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	642	test_cmp empty actual
	643	'
	644
	645	test_expect_success LIBPCRE 'grep -P pattern with grep.extendedRegexp=true' '
	646	git -c grep.extendedregexp=true \
	647	grep -P "\p{Ps}.*?\p{Pe}" hello.c >actual &&
	648	test_cmp expected actual
	649	'
	650
	651	test_expect_success LIBPCRE 'grep -P -v pattern' '
	652	{
	653	echo ab:a+b
	654	echo ab:a\\+b
	655	} >expected &&
	656	git grep -P -v "aab" ab >actual &&
	657	test_cmp expected actual
	658	'
	659
8f852ce6 MK	660	test_expect_success LIBPCRE 'grep -P -i pattern' '
	661	{
	662	echo "hello.c: printf(\"Hello world.\n\");"
	663	} >expected &&
	664	git grep -P -i "PRINTF\([^\d]+\)" hello.c >actual &&
	665	test_cmp expected actual
	666	'
	667
	668	test_expect_success LIBPCRE 'grep -P -w pattern' '
	669	{
	670	echo "hello_world:Hello world"
	671	echo "hello_world:HeLLo world"
	672	} >expected &&
	673	git grep -P -w "He((?i)ll)o" hello_world >actual &&
	674	test_cmp expected actual
	675	'
	676
f556e4af MK	677	test_expect_success 'grep -G invalidpattern properly dies ' '
	678	test_must_fail git grep -G "a["
	679	'
	680
	681	test_expect_success 'grep -E invalidpattern properly dies ' '
	682	test_must_fail git grep -E "a["
	683	'
	684
	685	test_expect_success LIBPCRE 'grep -P invalidpattern properly dies ' '
	686	test_must_fail git grep -P "a["
	687	'
	688
	689	test_expect_success 'grep -F -E -G pattern' '
	690	echo ab:a+b >expected &&
	691	git grep -F -E -G a+b >actual &&
	692	test_cmp expected actual
	693	'
	694
	695	test_expect_success 'grep -F -G -E pattern' '
	696	echo ab:aab >expected &&
	697	git grep -F -G -E a+b >actual &&
	698	test_cmp expected actual
	699	'
	700
	701	test_expect_success 'grep -E -F -G pattern' '
	702	echo ab:aab >expected &&
	703	git grep -E -F -G a\\+b >actual &&
	704	test_cmp expected actual
	705	'
	706
	707	test_expect_success 'grep -E -G -F pattern' '
	708	echo ab:a\\+b >expected &&
	709	git grep -E -G -F a\\+b >actual &&
	710	test_cmp expected actual
	711	'
	712
	713	test_expect_success 'grep -G -F -E pattern' '
	714	echo ab:a+b >expected &&
	715	git grep -G -F -E a\\+b >actual &&
	716	test_cmp expected actual
	717	'
	718
	719	test_expect_success LIBPCRE 'grep -E -G -F -P pattern' '
	720	echo ab:a+b >expected &&
	721	git grep -E -G -F -P a\\+b >actual &&
	722	test_cmp expected actual
	723	'
	724
f25b7939	725	test_done