[thirdparty/git.git] / t / t7002-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 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 grep -n -w -e mmap $H >actual &&
		diff expected actual
	'

	test_expect_success "grep -w $L (w)" '
		: >expected &&
		! 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 &&
		diff 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 &&
		diff 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
			diff 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
			diff expected actual
		fi
	'

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

	test_expect_success "grep $L (t-2)" '
		echo "${HC}t:1:test" >expected &&
		(
			cd t &&
			git grep -n -e test $H
		) >actual &&
		diff 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 &&
		diff 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
	'

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
'

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

# 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"

'

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 --grep=Thu --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 '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_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 &&
a91f453f	29	echo vvv >v &&
dbb6a4ad	30	echo ww w >w &&
f25b7939 JH	31	echo x x xx x >x &&
	32	echo y yy >y &&
	33	echo zzz > z &&
0d042fec JH	34	mkdir t &&
0d042fec JH	35	echo test >t/t &&
a91f453f MK	36	echo vvv >t/v &&
	37	mkdir t/a &&
	38	echo vvv >t/a/v &&
	39	git add . &&
a4d7d2c6	40	test_tick &&
f25b7939 JH	41	git commit -m initial
	42	'
	43
c922b01f LT	44	test_expect_success 'grep should not segfault with a bad input' '
	45	test_must_fail git grep "("
	46	'
	47
f25b7939 JH	48	for H in HEAD ''
	49	do
	50	case "$H" in
	51	HEAD) HC='HEAD:' L='HEAD' ;;
	52	'') HC= L='in working tree' ;;
	53	esac
	54
	55	test_expect_success "grep -w $L" '
	56	{
	57	echo ${HC}file:1:foo mmap bar
	58	echo ${HC}file:3:foo_mmap bar mmap
	59	echo ${HC}file:4:foo mmap bar_mmap
	60	echo ${HC}file:5:foo_mmap bar mmap baz
	61	} >expected &&
	62	git grep -n -w -e mmap $H >actual &&
	63	diff expected actual
	64	'
	65
dbb6a4ad RS	66	test_expect_success "grep -w $L (w)" '
	67	: >expected &&
	68	! git grep -n -w -e "^w" >actual &&
	69	test_cmp expected actual
	70	'
	71
f25b7939 JH	72	test_expect_success "grep -w $L (x)" '
	73	{
	74	echo ${HC}x:1:x x xx x
	75	} >expected &&
	76	git grep -n -w -e "x xx* x" $H >actual &&
	77	diff expected actual
	78	'
	79
	80	test_expect_success "grep -w $L (y-1)" '
	81	{
	82	echo ${HC}y:1:y yy
	83	} >expected &&
	84	git grep -n -w -e "^y" $H >actual &&
	85	diff expected actual
	86	'
	87
	88	test_expect_success "grep -w $L (y-2)" '
	89	: >expected &&
	90	if git grep -n -w -e "^y y" $H >actual
	91	then
	92	echo should not have matched
	93	cat actual
	94	false
	95	else
	96	diff expected actual
	97	fi
	98	'
	99
	100	test_expect_success "grep -w $L (z)" '
	101	: >expected &&
	102	if git grep -n -w -e "^z" $H >actual
	103	then
	104	echo should not have matched
	105	cat actual
	106	false
	107	else
	108	diff expected actual
	109	fi
	110	'
0d042fec JH	111
	112	test_expect_success "grep $L (t-1)" '
	113	echo "${HC}t/t:1:test" >expected &&
	114	git grep -n -e test $H >actual &&
	115	diff expected actual
	116	'
	117
	118	test_expect_success "grep $L (t-2)" '
	119	echo "${HC}t:1:test" >expected &&
	120	(
	121	cd t &&
	122	git grep -n -e test $H
	123	) >actual &&
	124	diff expected actual
	125	'
	126
	127	test_expect_success "grep $L (t-3)" '
	128	echo "${HC}t/t:1:test" >expected &&
	129	(
	130	cd t &&
	131	git grep --full-name -n -e test $H
	132	) >actual &&
	133	diff expected actual
	134	'
	135
41ac414e	136	test_expect_success "grep -c $L (no /dev/null)" '
87539416	137	! git grep -c test $H \| grep /dev/null
d99ebf08 JH	138	'
d99ebf08 JH	139
a91f453f MK	140	test_expect_success "grep --max-depth -1 $L" '
	141	{
	142	echo ${HC}t/a/v:1:vvv
	143	echo ${HC}t/v:1:vvv
	144	echo ${HC}v:1:vvv
	145	} >expected &&
	146	git grep --max-depth -1 -n -e vvv $H >actual &&
	147	test_cmp expected actual
	148	'
	149
	150	test_expect_success "grep --max-depth 0 $L" '
	151	{
	152	echo ${HC}v:1:vvv
	153	} >expected &&
	154	git grep --max-depth 0 -n -e vvv $H >actual &&
	155	test_cmp expected actual
	156	'
	157
	158	test_expect_success "grep --max-depth 0 -- '*' $L" '
	159	{
	160	echo ${HC}t/a/v:1:vvv
	161	echo ${HC}t/v:1:vvv
	162	echo ${HC}v:1:vvv
	163	} >expected &&
	164	git grep --max-depth 0 -n -e vvv $H -- "*" >actual &&
	165	test_cmp expected actual
	166	'
	167
	168	test_expect_success "grep --max-depth 1 $L" '
	169	{
	170	echo ${HC}t/v:1:vvv
	171	echo ${HC}v:1:vvv
	172	} >expected &&
	173	git grep --max-depth 1 -n -e vvv $H >actual &&
	174	test_cmp expected actual
	175	'
	176
	177	test_expect_success "grep --max-depth 0 -- t $L" '
	178	{
	179	echo ${HC}t/v:1:vvv
	180	} >expected &&
	181	git grep --max-depth 0 -n -e vvv $H -- t >actual &&
	182	test_cmp expected actual
	183	'
	184
f25b7939 JH	185	done
f25b7939 JH	186
0f705046 TR	187	cat >expected <<EOF
	188	file:foo mmap bar_mmap
	189	EOF
	190
	191	test_expect_success 'grep -e A --and -e B' '
	192	git grep -e "foo mmap" --and -e bar_mmap >actual &&
	193	test_cmp expected actual
	194	'
	195
	196	cat >expected <<EOF
	197	file:foo_mmap bar mmap
	198	file:foo_mmap bar mmap baz
	199	EOF
	200
	201
	202	test_expect_success 'grep ( -e A --or -e B ) --and -e B' '
	203	git grep \( -e foo_ --or -e baz \) \
	204	--and -e " mmap" >actual &&
	205	test_cmp expected actual
	206	'
	207
	208	cat >expected <<EOF
	209	file:foo mmap bar
	210	EOF
	211
	212	test_expect_success 'grep -e A --and --not -e B' '
	213	git grep -e "foo mmap" --and --not -e bar_mmap >actual &&
	214	test_cmp expected actual
	215	'
	216
b4827599 RS	217	test_expect_success 'grep should ignore GREP_OPTIONS' '
	218	GREP_OPTIONS=-v git grep " mmap bar\$" >actual &&
	219	test_cmp expected actual
	220	'
	221
cfe370c6 MK	222	test_expect_success 'grep -f, non-existent file' '
	223	test_must_fail git grep -f patterns
	224	'
	225
	226	cat >expected <<EOF
	227	file:foo mmap bar
	228	file:foo_mmap bar
	229	file:foo_mmap bar mmap
	230	file:foo mmap bar_mmap
	231	file:foo_mmap bar mmap baz
	232	EOF
	233
	234	cat >pattern <<EOF
	235	mmap
	236	EOF
	237
	238	test_expect_success 'grep -f, one pattern' '
	239	git grep -f pattern >actual &&
	240	test_cmp expected actual
	241	'
	242
	243	cat >expected <<EOF
	244	file:foo mmap bar
	245	file:foo_mmap bar
	246	file:foo_mmap bar mmap
	247	file:foo mmap bar_mmap
	248	file:foo_mmap bar mmap baz
	249	t/a/v:vvv
	250	t/v:vvv
	251	v:vvv
	252	EOF
	253
	254	cat >patterns <<EOF
	255	mmap
	256	vvv
	257	EOF
	258
	259	test_expect_success 'grep -f, multiple patterns' '
	260	git grep -f patterns >actual &&
	261	test_cmp expected actual
	262	'
	263
	264	cat >expected <<EOF
	265	file:foo mmap bar
	266	file:foo_mmap bar
	267	file:foo_mmap bar mmap
	268	file:foo mmap bar_mmap
	269	file:foo_mmap bar mmap baz
	270	t/a/v:vvv
	271	t/v:vvv
	272	v:vvv
	273	EOF
	274
	275	cat >patterns <<EOF
	276
	277	mmap
	278
	279	vvv
	280
	281	EOF
	282
	283	test_expect_success 'grep -f, ignore empty lines' '
	284	git grep -f patterns >actual &&
	285	test_cmp expected actual
286	'
287
046802d0 RS	288	cat >expected <<EOF
	289	y:y yy
	290	--
	291	z:zzz
	292	EOF
	293
	294	# Create 1024 file names that sort between "y" and "z" to make sure
	295	# the two files are handled by different calls to an external grep.
	296	# This depends on MAXARGS in builtin-grep.c being 1024 or less.
	297	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"
	298	test_expect_success 'grep -C1, hunk mark between files' '
	299	for a in $c32; do for b in $c32; do : >y-$a$b; done; done &&
	300	git add y-?? &&
	301	git grep -C1 "^[yz]" >actual &&
	302	test_cmp expected actual
	303	'
	304
bbc09c22 JH	305	test_expect_success 'grep -C1 hunk mark between files' '
bbc09c22 JH	306	git grep -C1 "^[yz]" >actual &&
046802d0 RS	307	test_cmp expected actual
	308	'
	309
a4d7d2c6 JH	310	test_expect_success 'log grep setup' '
	311	echo a >>file &&
	312	test_tick &&
	313	GIT_AUTHOR_NAME="With * Asterisk" \
	314	GIT_AUTHOR_EMAIL="xyzzy@frotz.com" \
	315	git commit -a -m "second" &&
	316
	317	echo a >>file &&
	318	test_tick &&
	319	git commit -a -m "third"
	320
	321	'
	322
	323	test_expect_success 'log grep (1)' '
	324	git log --author=author --pretty=tformat:%s >actual &&
	325	( echo third ; echo initial ) >expect &&
	326	test_cmp expect actual
	327	'
	328
	329	test_expect_success 'log grep (2)' '
	330	git log --author=" * " -F --pretty=tformat:%s >actual &&
	331	( echo second ) >expect &&
	332	test_cmp expect actual
	333	'
	334
	335	test_expect_success 'log grep (3)' '
	336	git log --author="^A U" --pretty=tformat:%s >actual &&
	337	( echo third ; echo initial ) >expect &&
	338	test_cmp expect actual
	339	'
	340
	341	test_expect_success 'log grep (4)' '
	342	git log --author="frotz\.com>$" --pretty=tformat:%s >actual &&
	343	( echo second ) >expect &&
	344	test_cmp expect actual
	345	'
	346
	347	test_expect_success 'log grep (5)' '
	348	git log --author=Thor -F --grep=Thu --pretty=tformat:%s >actual &&
	349	( echo third ; echo initial ) >expect &&
	350	test_cmp expect actual
	351	'
	352
	353	test_expect_success 'log grep (6)' '
	354	git log --author=-0700 --pretty=tformat:%s >actual &&
	355	>expect &&
	356	test_cmp expect actual
57d43466	357	'
a4d7d2c6	358
57d43466 NTND	359	test_expect_success 'grep with CE_VALID file' '
	360	git update-index --assume-unchanged t/t &&
	361	rm t/t &&
bbc09c22	362	test "$(git grep test)" = "t/t:test" &&
57d43466 NTND	363	git update-index --no-assume-unchanged t/t &&
57d43466 NTND	364	git checkout t/t
a4d7d2c6 JH	365	'
a4d7d2c6 JH	366
60ecac98 RS	367	cat >expected <<EOF
	368	hello.c=#include <stdio.h>
	369	hello.c: return 0;
	370	EOF
	371
	372	test_expect_success 'grep -p with userdiff' '
	373	git config diff.custom.funcname "^#" &&
	374	echo "hello.c diff=custom" >.gitattributes &&
	375	git grep -p return >actual &&
	376	test_cmp expected actual
	377	'
	378
2944e4e6 RS	379	cat >expected <<EOF
	380	hello.c=int main(int argc, const char **argv)
	381	hello.c: return 0;
	382	EOF
	383
	384	test_expect_success 'grep -p' '
60ecac98	385	rm -f .gitattributes &&
2944e4e6 RS	386	git grep -p return >actual &&
	387	test_cmp expected actual
	388	'
	389
	390	cat >expected <<EOF
	391	hello.c-#include <stdio.h>
	392	hello.c=int main(int argc, const char **argv)
	393	hello.c-{
	394	hello.c- printf("Hello world.\n");
	395	hello.c: return 0;
	396	EOF
	397
	398	test_expect_success 'grep -p -B5' '
	399	git grep -p -B5 return >actual &&
	400	test_cmp expected actual
	401	'
	402
493b7a08 CB	403	test_expect_success 'grep from a subdirectory to search wider area (1)' '
	404	mkdir -p s &&
	405	(
	406	cd s && git grep "x x x" ..
	407	)
	408	'
	409
	410	test_expect_success 'grep from a subdirectory to search wider area (2)' '
	411	mkdir -p s &&
	412	(
	413	cd s \|\| exit 1
	414	( git grep xxyyzz .. >out ; echo $? >status )
	415	! test -s out &&
	416	test 1 = $(cat status)
	417	)
	418	'
	419
5183bf67 BC	420	cat >expected <<EOF
	421	hello.c:int main(int argc, const char **argv)
	422	EOF
	423
	424	test_expect_success 'grep -Fi' '
	425	git grep -Fi "CHAR *" >actual &&
	426	test_cmp expected actual
	427	'
	428
30816237 JH	429	test_expect_success 'outside of git repository' '
	430	rm -fr non &&
	431	mkdir -p non/git/sub &&
	432	echo hello >non/git/file1 &&
	433	echo world >non/git/sub/file2 &&
	434	echo ".o" >non/git/.gitignore &&
	435	{
	436	echo file1:hello &&
	437	echo sub/file2:world
	438	} >non/expect.full &&
	439	echo file2:world >non/expect.sub
	440	(
	441	GIT_CEILING_DIRECTORIES="$(pwd)/non/git" &&
	442	export GIT_CEILING_DIRECTORIES &&
	443	cd non/git &&
	444	test_must_fail git grep o &&
	445	git grep --no-index o >../actual.full &&
	446	test_cmp ../expect.full ../actual.full
	447	cd sub &&
	448	test_must_fail git grep o &&
	449	git grep --no-index o >../../actual.sub &&
	450	test_cmp ../../expect.sub ../../actual.sub
	451	)
	452	'
	453
	454	test_expect_success 'inside git repository but with --no-index' '
	455	rm -fr is &&
	456	mkdir -p is/git/sub &&
	457	echo hello >is/git/file1 &&
	458	echo world >is/git/sub/file2 &&
	459	echo ".o" >is/git/.gitignore &&
	460	{
	461	echo file1:hello &&
	462	echo sub/file2:world
	463	} >is/expect.full &&
	464	: >is/expect.empty &&
	465	echo file2:world >is/expect.sub
	466	(
	467	cd is/git &&
	468	git init &&
	469	test_must_fail git grep o >../actual.full &&
	470	test_cmp ../expect.empty ../actual.full &&
	471	git grep --no-index o >../actual.full &&
	472	test_cmp ../expect.full ../actual.full &&
	473	cd sub &&
	474	test_must_fail git grep o >../../actual.sub &&
	475	test_cmp ../../expect.empty ../../actual.sub &&
	476	git grep --no-index o >../../actual.sub &&
	477	test_cmp ../../expect.sub ../../actual.sub
	478	)
	479	'
	480
f25b7939	481	test_done