845 lines
21 KiB
Bash
Executable File
845 lines
21 KiB
Bash
Executable File
#!/bin/sh
|
|
|
|
test_description=check-ignore
|
|
|
|
. ./test-lib.sh
|
|
|
|
init_vars () {
|
|
global_excludes="global-excludes"
|
|
}
|
|
|
|
enable_global_excludes () {
|
|
init_vars &&
|
|
git config core.excludesfile "$global_excludes"
|
|
}
|
|
|
|
expect_in () {
|
|
dest="$HOME/expected-$1" text="$2"
|
|
if test -z "$text"
|
|
then
|
|
>"$dest" # avoid newline
|
|
else
|
|
echo "$text" >"$dest"
|
|
fi
|
|
}
|
|
|
|
expect () {
|
|
expect_in stdout "$1"
|
|
}
|
|
|
|
expect_from_stdin () {
|
|
cat >"$HOME/expected-stdout"
|
|
}
|
|
|
|
test_stderr () {
|
|
expected="$1"
|
|
expect_in stderr "$1" &&
|
|
test_i18ncmp "$HOME/expected-stderr" "$HOME/stderr"
|
|
}
|
|
|
|
broken_c_unquote () {
|
|
"$PERL_PATH" -pe 's/^"//; s/\\//; s/"$//; tr/\n/\0/' "$@"
|
|
}
|
|
|
|
broken_c_unquote_verbose () {
|
|
"$PERL_PATH" -pe 's/ "/ /; s/\\//; s/"$//; tr/:\t\n/\0/' "$@"
|
|
}
|
|
|
|
stderr_contains () {
|
|
regexp="$1"
|
|
if test_i18ngrep "$regexp" "$HOME/stderr"
|
|
then
|
|
return 0
|
|
else
|
|
echo "didn't find /$regexp/ in $HOME/stderr"
|
|
cat "$HOME/stderr"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
stderr_empty_on_success () {
|
|
expect_code="$1"
|
|
if test $expect_code = 0
|
|
then
|
|
test_stderr ""
|
|
else
|
|
# If we expect failure then stderr might or might not be empty
|
|
# due to --quiet - the caller can check its contents
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
test_check_ignore () {
|
|
args="$1" expect_code="${2:-0}" global_args="$3"
|
|
|
|
init_vars &&
|
|
rm -f "$HOME/stdout" "$HOME/stderr" "$HOME/cmd" &&
|
|
echo git $global_args check-ignore $quiet_opt $verbose_opt $non_matching_opt $no_index_opt $args \
|
|
>"$HOME/cmd" &&
|
|
echo "$expect_code" >"$HOME/expected-exit-code" &&
|
|
test_expect_code "$expect_code" \
|
|
git $global_args check-ignore $quiet_opt $verbose_opt $non_matching_opt $no_index_opt $args \
|
|
>"$HOME/stdout" 2>"$HOME/stderr" &&
|
|
test_cmp "$HOME/expected-stdout" "$HOME/stdout" &&
|
|
stderr_empty_on_success "$expect_code"
|
|
}
|
|
|
|
# Runs the same code with 4 different levels of output verbosity:
|
|
#
|
|
# 1. with -q / --quiet
|
|
# 2. with default verbosity
|
|
# 3. with -v / --verbose
|
|
# 4. with -v / --verbose, *and* -n / --non-matching
|
|
#
|
|
# expecting success each time. Takes advantage of the fact that
|
|
# check-ignore --verbose output is the same as normal output except
|
|
# for the extra first column.
|
|
#
|
|
# A parameter is used to determine if the tests are run with the
|
|
# normal case (using the index), or with the --no-index option.
|
|
#
|
|
# Arguments:
|
|
# - (optional) prereqs for this test, e.g. 'SYMLINKS'
|
|
# - test name
|
|
# - output to expect from the fourth verbosity mode (the output
|
|
# from the other verbosity modes is automatically inferred
|
|
# from this value)
|
|
# - code to run (should invoke test_check_ignore)
|
|
# - index option: --index or --no-index
|
|
test_expect_success_multiple () {
|
|
prereq=
|
|
if test $# -eq 5
|
|
then
|
|
prereq=$1
|
|
shift
|
|
fi
|
|
if test "$4" = "--index"
|
|
then
|
|
no_index_opt=
|
|
else
|
|
no_index_opt=$4
|
|
fi
|
|
testname="$1" expect_all="$2" code="$3"
|
|
|
|
expect_verbose=$( echo "$expect_all" | grep -v '^:: ' )
|
|
expect=$( echo "$expect_verbose" | sed -e 's/.* //' )
|
|
|
|
test_expect_success $prereq "$testname${no_index_opt:+ with $no_index_opt}" '
|
|
expect "$expect" &&
|
|
eval "$code"
|
|
'
|
|
|
|
# --quiet is only valid when a single pattern is passed
|
|
if test $( echo "$expect_all" | wc -l ) = 1
|
|
then
|
|
for quiet_opt in '-q' '--quiet'
|
|
do
|
|
opts="${no_index_opt:+$no_index_opt }$quiet_opt"
|
|
test_expect_success $prereq "$testname${opts:+ with $opts}" "
|
|
expect '' &&
|
|
$code
|
|
"
|
|
done
|
|
quiet_opt=
|
|
fi
|
|
|
|
for verbose_opt in '-v' '--verbose'
|
|
do
|
|
for non_matching_opt in '' '-n' '--non-matching'
|
|
do
|
|
if test -n "$non_matching_opt"
|
|
then
|
|
my_expect="$expect_all"
|
|
else
|
|
my_expect="$expect_verbose"
|
|
fi
|
|
|
|
test_code="
|
|
expect '$my_expect' &&
|
|
$code
|
|
"
|
|
opts="${no_index_opt:+$no_index_opt }$verbose_opt${non_matching_opt:+ $non_matching_opt}"
|
|
test_expect_success $prereq "$testname${opts:+ with $opts}" "$test_code"
|
|
done
|
|
done
|
|
verbose_opt=
|
|
non_matching_opt=
|
|
no_index_opt=
|
|
}
|
|
|
|
test_expect_success_multi () {
|
|
test_expect_success_multiple "$@" "--index"
|
|
}
|
|
|
|
test_expect_success_no_index_multi () {
|
|
test_expect_success_multiple "$@" "--no-index"
|
|
}
|
|
|
|
test_expect_success 'setup' '
|
|
init_vars &&
|
|
mkdir -p a/b/ignored-dir a/submodule b &&
|
|
if test_have_prereq SYMLINKS
|
|
then
|
|
ln -s b a/symlink
|
|
fi &&
|
|
(
|
|
cd a/submodule &&
|
|
git init &&
|
|
echo a >a &&
|
|
git add a &&
|
|
git commit -m"commit in submodule"
|
|
) &&
|
|
git add a/submodule &&
|
|
cat <<-\EOF >.gitignore &&
|
|
one
|
|
ignored-*
|
|
top-level-dir/
|
|
EOF
|
|
for dir in . a
|
|
do
|
|
: >$dir/not-ignored &&
|
|
: >$dir/ignored-and-untracked &&
|
|
: >$dir/ignored-but-in-index
|
|
done &&
|
|
git add -f ignored-but-in-index a/ignored-but-in-index &&
|
|
cat <<-\EOF >a/.gitignore &&
|
|
two*
|
|
*three
|
|
EOF
|
|
cat <<-\EOF >a/b/.gitignore &&
|
|
four
|
|
five
|
|
# this comment should affect the line numbers
|
|
six
|
|
ignored-dir/
|
|
# and so should this blank line:
|
|
|
|
!on*
|
|
!two
|
|
EOF
|
|
echo "seven" >a/b/ignored-dir/.gitignore &&
|
|
test -n "$HOME" &&
|
|
cat <<-\EOF >"$global_excludes" &&
|
|
globalone
|
|
!globaltwo
|
|
globalthree
|
|
EOF
|
|
cat <<-\EOF >>.git/info/exclude
|
|
per-repo
|
|
EOF
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test invalid inputs
|
|
|
|
test_expect_success_multi '. corner-case' ':: .' '
|
|
test_check_ignore . 1
|
|
'
|
|
|
|
test_expect_success_multi 'empty command line' '' '
|
|
test_check_ignore "" 128 &&
|
|
stderr_contains "fatal: no path specified"
|
|
'
|
|
|
|
test_expect_success_multi '--stdin with empty STDIN' '' '
|
|
test_check_ignore "--stdin" 1 </dev/null &&
|
|
test_stderr ""
|
|
'
|
|
|
|
test_expect_success '-q with multiple args' '
|
|
expect "" &&
|
|
test_check_ignore "-q one two" 128 &&
|
|
stderr_contains "fatal: --quiet is only valid with a single pathname"
|
|
'
|
|
|
|
test_expect_success '--quiet with multiple args' '
|
|
expect "" &&
|
|
test_check_ignore "--quiet one two" 128 &&
|
|
stderr_contains "fatal: --quiet is only valid with a single pathname"
|
|
'
|
|
|
|
for verbose_opt in '-v' '--verbose'
|
|
do
|
|
for quiet_opt in '-q' '--quiet'
|
|
do
|
|
test_expect_success "$quiet_opt $verbose_opt" "
|
|
expect '' &&
|
|
test_check_ignore '$quiet_opt $verbose_opt foo' 128 &&
|
|
stderr_contains 'fatal: cannot have both --quiet and --verbose'
|
|
"
|
|
done
|
|
done
|
|
|
|
test_expect_success '--quiet with multiple args' '
|
|
expect "" &&
|
|
test_check_ignore "--quiet one two" 128 &&
|
|
stderr_contains "fatal: --quiet is only valid with a single pathname"
|
|
'
|
|
|
|
test_expect_success_multi 'erroneous use of --' '' '
|
|
test_check_ignore "--" 128 &&
|
|
stderr_contains "fatal: no path specified"
|
|
'
|
|
|
|
test_expect_success_multi '--stdin with superfluous arg' '' '
|
|
test_check_ignore "--stdin foo" 128 &&
|
|
stderr_contains "fatal: cannot specify pathnames with --stdin"
|
|
'
|
|
|
|
test_expect_success_multi '--stdin -z with superfluous arg' '' '
|
|
test_check_ignore "--stdin -z foo" 128 &&
|
|
stderr_contains "fatal: cannot specify pathnames with --stdin"
|
|
'
|
|
|
|
test_expect_success_multi '-z without --stdin' '' '
|
|
test_check_ignore "-z" 128 &&
|
|
stderr_contains "fatal: -z only makes sense with --stdin"
|
|
'
|
|
|
|
test_expect_success_multi '-z without --stdin and superfluous arg' '' '
|
|
test_check_ignore "-z foo" 128 &&
|
|
stderr_contains "fatal: -z only makes sense with --stdin"
|
|
'
|
|
|
|
test_expect_success_multi 'needs work tree' '' '
|
|
(
|
|
cd .git &&
|
|
test_check_ignore "foo" 128
|
|
) &&
|
|
stderr_contains "fatal: This operation must be run in a work tree"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test standard ignores
|
|
|
|
# First make sure that the presence of a file in the working tree
|
|
# does not impact results, but that the presence of a file in the
|
|
# index does unless the --no-index option is used.
|
|
|
|
for subdir in '' 'a/'
|
|
do
|
|
if test -z "$subdir"
|
|
then
|
|
where="at top-level"
|
|
else
|
|
where="in subdir $subdir"
|
|
fi
|
|
|
|
test_expect_success_multi "non-existent file $where not ignored" \
|
|
":: ${subdir}non-existent" \
|
|
"test_check_ignore '${subdir}non-existent' 1"
|
|
|
|
test_expect_success_no_index_multi "non-existent file $where not ignored" \
|
|
":: ${subdir}non-existent" \
|
|
"test_check_ignore '${subdir}non-existent' 1"
|
|
|
|
test_expect_success_multi "non-existent file $where ignored" \
|
|
".gitignore:1:one ${subdir}one" \
|
|
"test_check_ignore '${subdir}one'"
|
|
|
|
test_expect_success_no_index_multi "non-existent file $where ignored" \
|
|
".gitignore:1:one ${subdir}one" \
|
|
"test_check_ignore '${subdir}one'"
|
|
|
|
test_expect_success_multi "existing untracked file $where not ignored" \
|
|
":: ${subdir}not-ignored" \
|
|
"test_check_ignore '${subdir}not-ignored' 1"
|
|
|
|
test_expect_success_no_index_multi "existing untracked file $where not ignored" \
|
|
":: ${subdir}not-ignored" \
|
|
"test_check_ignore '${subdir}not-ignored' 1"
|
|
|
|
test_expect_success_multi "existing tracked file $where not ignored" \
|
|
":: ${subdir}ignored-but-in-index" \
|
|
"test_check_ignore '${subdir}ignored-but-in-index' 1"
|
|
|
|
test_expect_success_no_index_multi "existing tracked file $where shown as ignored" \
|
|
".gitignore:2:ignored-* ${subdir}ignored-but-in-index" \
|
|
"test_check_ignore '${subdir}ignored-but-in-index'"
|
|
|
|
test_expect_success_multi "existing untracked file $where ignored" \
|
|
".gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
|
|
"test_check_ignore '${subdir}ignored-and-untracked'"
|
|
|
|
test_expect_success_no_index_multi "existing untracked file $where ignored" \
|
|
".gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
|
|
"test_check_ignore '${subdir}ignored-and-untracked'"
|
|
|
|
test_expect_success_multi "mix of file types $where" \
|
|
":: ${subdir}non-existent
|
|
.gitignore:1:one ${subdir}one
|
|
:: ${subdir}not-ignored
|
|
:: ${subdir}ignored-but-in-index
|
|
.gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
|
|
"test_check_ignore '
|
|
${subdir}non-existent
|
|
${subdir}one
|
|
${subdir}not-ignored
|
|
${subdir}ignored-but-in-index
|
|
${subdir}ignored-and-untracked'
|
|
"
|
|
|
|
test_expect_success_no_index_multi "mix of file types $where" \
|
|
":: ${subdir}non-existent
|
|
.gitignore:1:one ${subdir}one
|
|
:: ${subdir}not-ignored
|
|
.gitignore:2:ignored-* ${subdir}ignored-but-in-index
|
|
.gitignore:2:ignored-* ${subdir}ignored-and-untracked" \
|
|
"test_check_ignore '
|
|
${subdir}non-existent
|
|
${subdir}one
|
|
${subdir}not-ignored
|
|
${subdir}ignored-but-in-index
|
|
${subdir}ignored-and-untracked'
|
|
"
|
|
done
|
|
|
|
# Having established the above, from now on we mostly test against
|
|
# files which do not exist in the working tree or index.
|
|
|
|
test_expect_success 'sub-directory local ignore' '
|
|
expect "a/3-three" &&
|
|
test_check_ignore "a/3-three a/three-not-this-one"
|
|
'
|
|
|
|
test_expect_success 'sub-directory local ignore with --verbose' '
|
|
expect "a/.gitignore:2:*three a/3-three" &&
|
|
test_check_ignore "--verbose a/3-three a/three-not-this-one"
|
|
'
|
|
|
|
test_expect_success 'local ignore inside a sub-directory' '
|
|
expect "3-three" &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "3-three three-not-this-one"
|
|
)
|
|
'
|
|
test_expect_success 'local ignore inside a sub-directory with --verbose' '
|
|
expect "a/.gitignore:2:*three 3-three" &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "--verbose 3-three three-not-this-one"
|
|
)
|
|
'
|
|
|
|
test_expect_success_multi 'nested include' \
|
|
'a/b/.gitignore:8:!on* a/b/one' '
|
|
test_check_ignore "a/b/one"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test ignored sub-directories
|
|
|
|
test_expect_success_multi 'ignored sub-directory' \
|
|
'a/b/.gitignore:5:ignored-dir/ a/b/ignored-dir' '
|
|
test_check_ignore "a/b/ignored-dir"
|
|
'
|
|
|
|
test_expect_success 'multiple files inside ignored sub-directory' '
|
|
expect_from_stdin <<-\EOF &&
|
|
a/b/ignored-dir/foo
|
|
a/b/ignored-dir/twoooo
|
|
a/b/ignored-dir/seven
|
|
EOF
|
|
test_check_ignore "a/b/ignored-dir/foo a/b/ignored-dir/twoooo a/b/ignored-dir/seven"
|
|
'
|
|
|
|
test_expect_success 'multiple files inside ignored sub-directory with -v' '
|
|
expect_from_stdin <<-\EOF &&
|
|
a/b/.gitignore:5:ignored-dir/ a/b/ignored-dir/foo
|
|
a/b/.gitignore:5:ignored-dir/ a/b/ignored-dir/twoooo
|
|
a/b/.gitignore:5:ignored-dir/ a/b/ignored-dir/seven
|
|
EOF
|
|
test_check_ignore "-v a/b/ignored-dir/foo a/b/ignored-dir/twoooo a/b/ignored-dir/seven"
|
|
'
|
|
|
|
test_expect_success 'cd to ignored sub-directory' '
|
|
expect_from_stdin <<-\EOF &&
|
|
foo
|
|
twoooo
|
|
../one
|
|
seven
|
|
../../one
|
|
EOF
|
|
(
|
|
cd a/b/ignored-dir &&
|
|
test_check_ignore "foo twoooo ../one seven ../../one"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'cd to ignored sub-directory with -v' '
|
|
expect_from_stdin <<-\EOF &&
|
|
a/b/.gitignore:5:ignored-dir/ foo
|
|
a/b/.gitignore:5:ignored-dir/ twoooo
|
|
a/b/.gitignore:8:!on* ../one
|
|
a/b/.gitignore:5:ignored-dir/ seven
|
|
.gitignore:1:one ../../one
|
|
EOF
|
|
(
|
|
cd a/b/ignored-dir &&
|
|
test_check_ignore "-v foo twoooo ../one seven ../../one"
|
|
)
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test handling of symlinks
|
|
|
|
test_expect_success_multi SYMLINKS 'symlink' ':: a/symlink' '
|
|
test_check_ignore "a/symlink" 1
|
|
'
|
|
|
|
test_expect_success_multi SYMLINKS 'beyond a symlink' '' '
|
|
test_check_ignore "a/symlink/foo" 128 &&
|
|
test_stderr "fatal: pathspec '\''a/symlink/foo'\'' is beyond a symbolic link"
|
|
'
|
|
|
|
test_expect_success_multi SYMLINKS 'beyond a symlink from subdirectory' '' '
|
|
(
|
|
cd a &&
|
|
test_check_ignore "symlink/foo" 128
|
|
) &&
|
|
test_stderr "fatal: pathspec '\''symlink/foo'\'' is beyond a symbolic link"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test handling of submodules
|
|
|
|
test_expect_success_multi 'submodule' '' '
|
|
test_check_ignore "a/submodule/one" 128 &&
|
|
test_stderr "fatal: Pathspec '\''a/submodule/one'\'' is in submodule '\''a/submodule'\''"
|
|
'
|
|
|
|
test_expect_success_multi 'submodule from subdirectory' '' '
|
|
(
|
|
cd a &&
|
|
test_check_ignore "submodule/one" 128
|
|
) &&
|
|
test_stderr "fatal: Pathspec '\''submodule/one'\'' is in submodule '\''a/submodule'\''"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test handling of global ignore files
|
|
|
|
test_expect_success 'global ignore not yet enabled' '
|
|
expect_from_stdin <<-\EOF &&
|
|
.git/info/exclude:7:per-repo per-repo
|
|
a/.gitignore:2:*three a/globalthree
|
|
.git/info/exclude:7:per-repo a/per-repo
|
|
EOF
|
|
test_check_ignore "-v globalone per-repo a/globalthree a/per-repo not-ignored a/globaltwo"
|
|
'
|
|
|
|
test_expect_success 'global ignore' '
|
|
enable_global_excludes &&
|
|
expect_from_stdin <<-\EOF &&
|
|
globalone
|
|
per-repo
|
|
globalthree
|
|
a/globalthree
|
|
a/per-repo
|
|
globaltwo
|
|
EOF
|
|
test_check_ignore "globalone per-repo globalthree a/globalthree a/per-repo not-ignored globaltwo"
|
|
'
|
|
|
|
test_expect_success 'global ignore with -v' '
|
|
enable_global_excludes &&
|
|
expect_from_stdin <<-EOF &&
|
|
$global_excludes:1:globalone globalone
|
|
.git/info/exclude:7:per-repo per-repo
|
|
$global_excludes:3:globalthree globalthree
|
|
a/.gitignore:2:*three a/globalthree
|
|
.git/info/exclude:7:per-repo a/per-repo
|
|
$global_excludes:2:!globaltwo globaltwo
|
|
EOF
|
|
test_check_ignore "-v globalone per-repo globalthree a/globalthree a/per-repo not-ignored globaltwo"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test --stdin
|
|
|
|
cat <<-\EOF >stdin
|
|
one
|
|
not-ignored
|
|
a/one
|
|
a/not-ignored
|
|
a/b/on
|
|
a/b/one
|
|
a/b/one one
|
|
"a/b/one two"
|
|
"a/b/one\"three"
|
|
a/b/not-ignored
|
|
a/b/two
|
|
a/b/twooo
|
|
globaltwo
|
|
a/globaltwo
|
|
a/b/globaltwo
|
|
b/globaltwo
|
|
EOF
|
|
cat <<-\EOF >expected-default
|
|
one
|
|
a/one
|
|
a/b/on
|
|
a/b/one
|
|
a/b/one one
|
|
a/b/one two
|
|
"a/b/one\"three"
|
|
a/b/two
|
|
a/b/twooo
|
|
globaltwo
|
|
a/globaltwo
|
|
a/b/globaltwo
|
|
b/globaltwo
|
|
EOF
|
|
cat <<-EOF >expected-verbose
|
|
.gitignore:1:one one
|
|
.gitignore:1:one a/one
|
|
a/b/.gitignore:8:!on* a/b/on
|
|
a/b/.gitignore:8:!on* a/b/one
|
|
a/b/.gitignore:8:!on* a/b/one one
|
|
a/b/.gitignore:8:!on* a/b/one two
|
|
a/b/.gitignore:8:!on* "a/b/one\\"three"
|
|
a/b/.gitignore:9:!two a/b/two
|
|
a/.gitignore:1:two* a/b/twooo
|
|
$global_excludes:2:!globaltwo globaltwo
|
|
$global_excludes:2:!globaltwo a/globaltwo
|
|
$global_excludes:2:!globaltwo a/b/globaltwo
|
|
$global_excludes:2:!globaltwo b/globaltwo
|
|
EOF
|
|
|
|
broken_c_unquote stdin >stdin0
|
|
|
|
broken_c_unquote expected-default >expected-default0
|
|
|
|
broken_c_unquote_verbose expected-verbose >expected-verbose0
|
|
|
|
test_expect_success '--stdin' '
|
|
expect_from_stdin <expected-default &&
|
|
test_check_ignore "--stdin" <stdin
|
|
'
|
|
|
|
test_expect_success '--stdin -q' '
|
|
expect "" &&
|
|
test_check_ignore "-q --stdin" <stdin
|
|
'
|
|
|
|
test_expect_success '--stdin -v' '
|
|
expect_from_stdin <expected-verbose &&
|
|
test_check_ignore "-v --stdin" <stdin
|
|
'
|
|
|
|
for opts in '--stdin -z' '-z --stdin'
|
|
do
|
|
test_expect_success "$opts" "
|
|
expect_from_stdin <expected-default0 &&
|
|
test_check_ignore '$opts' <stdin0
|
|
"
|
|
|
|
test_expect_success "$opts -q" "
|
|
expect "" &&
|
|
test_check_ignore '-q $opts' <stdin0
|
|
"
|
|
|
|
test_expect_success "$opts -v" "
|
|
expect_from_stdin <expected-verbose0 &&
|
|
test_check_ignore '-v $opts' <stdin0
|
|
"
|
|
done
|
|
|
|
cat <<-\EOF >stdin
|
|
../one
|
|
../not-ignored
|
|
one
|
|
not-ignored
|
|
b/on
|
|
b/one
|
|
b/one one
|
|
"b/one two"
|
|
"b/one\"three"
|
|
b/two
|
|
b/not-ignored
|
|
b/twooo
|
|
../globaltwo
|
|
globaltwo
|
|
b/globaltwo
|
|
../b/globaltwo
|
|
c/not-ignored
|
|
EOF
|
|
# N.B. we deliberately end STDIN with a non-matching pattern in order
|
|
# to test that the exit code indicates that one or more of the
|
|
# provided paths is ignored - in other words, that it represents an
|
|
# aggregation of all the results, not just the final result.
|
|
|
|
cat <<-EOF >expected-all
|
|
.gitignore:1:one ../one
|
|
:: ../not-ignored
|
|
.gitignore:1:one one
|
|
:: not-ignored
|
|
a/b/.gitignore:8:!on* b/on
|
|
a/b/.gitignore:8:!on* b/one
|
|
a/b/.gitignore:8:!on* b/one one
|
|
a/b/.gitignore:8:!on* b/one two
|
|
a/b/.gitignore:8:!on* "b/one\\"three"
|
|
a/b/.gitignore:9:!two b/two
|
|
:: b/not-ignored
|
|
a/.gitignore:1:two* b/twooo
|
|
$global_excludes:2:!globaltwo ../globaltwo
|
|
$global_excludes:2:!globaltwo globaltwo
|
|
$global_excludes:2:!globaltwo b/globaltwo
|
|
$global_excludes:2:!globaltwo ../b/globaltwo
|
|
:: c/not-ignored
|
|
EOF
|
|
grep -v '^:: ' expected-all >expected-verbose
|
|
sed -e 's/.* //' expected-verbose >expected-default
|
|
|
|
broken_c_unquote stdin >stdin0
|
|
|
|
broken_c_unquote expected-default >expected-default0
|
|
|
|
broken_c_unquote_verbose expected-verbose >expected-verbose0
|
|
|
|
test_expect_success '--stdin from subdirectory' '
|
|
expect_from_stdin <expected-default &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "--stdin" <../stdin
|
|
)
|
|
'
|
|
|
|
test_expect_success '--stdin from subdirectory with -v' '
|
|
expect_from_stdin <expected-verbose &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "--stdin -v" <../stdin
|
|
)
|
|
'
|
|
|
|
test_expect_success '--stdin from subdirectory with -v -n' '
|
|
expect_from_stdin <expected-all &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "--stdin -v -n" <../stdin
|
|
)
|
|
'
|
|
|
|
for opts in '--stdin -z' '-z --stdin'
|
|
do
|
|
test_expect_success "$opts from subdirectory" '
|
|
expect_from_stdin <expected-default0 &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "'"$opts"'" <../stdin0
|
|
)
|
|
'
|
|
|
|
test_expect_success "$opts from subdirectory with -v" '
|
|
expect_from_stdin <expected-verbose0 &&
|
|
(
|
|
cd a &&
|
|
test_check_ignore "'"$opts"' -v" <../stdin0
|
|
)
|
|
'
|
|
done
|
|
|
|
test_expect_success PIPE 'streaming support for --stdin' '
|
|
mkfifo in out &&
|
|
(git check-ignore -n -v --stdin <in >out &) &&
|
|
|
|
# We cannot just "echo >in" because check-ignore would get EOF
|
|
# after echo exited; instead we open the descriptor in our
|
|
# shell, and then echo to the fd. We make sure to close it at
|
|
# the end, so that the subprocess does get EOF and dies
|
|
# properly.
|
|
#
|
|
# Similarly, we must keep "out" open so that check-ignore does
|
|
# not ever get SIGPIPE trying to write to us. Not only would that
|
|
# produce incorrect results, but then there would be no writer on the
|
|
# other end of the pipe, and we would potentially block forever trying
|
|
# to open it.
|
|
exec 9>in &&
|
|
exec 8<out &&
|
|
test_when_finished "exec 9>&-" &&
|
|
test_when_finished "exec 8<&-" &&
|
|
echo >&9 one &&
|
|
read response <&8 &&
|
|
echo "$response" | grep "^\.gitignore:1:one one" &&
|
|
echo >&9 two &&
|
|
read response <&8 &&
|
|
echo "$response" | grep "^:: two"
|
|
'
|
|
|
|
############################################################################
|
|
#
|
|
# test whitespace handling
|
|
|
|
test_expect_success 'trailing whitespace is ignored' '
|
|
mkdir whitespace &&
|
|
>whitespace/trailing &&
|
|
>whitespace/untracked &&
|
|
echo "whitespace/trailing " >ignore &&
|
|
cat >expect <<EOF &&
|
|
whitespace/untracked
|
|
EOF
|
|
: >err.expect &&
|
|
git ls-files -o -X ignore whitespace >actual 2>err &&
|
|
test_cmp expect actual &&
|
|
test_cmp err.expect err
|
|
'
|
|
|
|
test_expect_success !MINGW 'quoting allows trailing whitespace' '
|
|
rm -rf whitespace &&
|
|
mkdir whitespace &&
|
|
>"whitespace/trailing " &&
|
|
>whitespace/untracked &&
|
|
echo "whitespace/trailing\\ \\ " >ignore &&
|
|
echo whitespace/untracked >expect &&
|
|
: >err.expect &&
|
|
git ls-files -o -X ignore whitespace >actual 2>err &&
|
|
test_cmp expect actual &&
|
|
test_cmp err.expect err
|
|
'
|
|
|
|
test_expect_success !MINGW,!CYGWIN 'correct handling of backslashes' '
|
|
rm -rf whitespace &&
|
|
mkdir whitespace &&
|
|
>"whitespace/trailing 1 " &&
|
|
>"whitespace/trailing 2 \\\\" &&
|
|
>"whitespace/trailing 3 \\\\" &&
|
|
>"whitespace/trailing 4 \\ " &&
|
|
>"whitespace/trailing 5 \\ \\ " &&
|
|
>"whitespace/trailing 6 \\a\\" &&
|
|
>whitespace/untracked &&
|
|
sed -e "s/Z$//" >ignore <<-\EOF &&
|
|
whitespace/trailing 1 \ Z
|
|
whitespace/trailing 2 \\\\Z
|
|
whitespace/trailing 3 \\\\ Z
|
|
whitespace/trailing 4 \\\ Z
|
|
whitespace/trailing 5 \\ \\\ Z
|
|
whitespace/trailing 6 \\a\\Z
|
|
EOF
|
|
echo whitespace/untracked >expect &&
|
|
>err.expect &&
|
|
git ls-files -o -X ignore whitespace >actual 2>err &&
|
|
test_cmp expect actual &&
|
|
test_cmp err.expect err
|
|
'
|
|
|
|
test_expect_success 'info/exclude trumps core.excludesfile' '
|
|
echo >>global-excludes usually-ignored &&
|
|
echo >>.git/info/exclude "!usually-ignored" &&
|
|
>usually-ignored &&
|
|
echo "?? usually-ignored" >expect &&
|
|
|
|
git status --porcelain usually-ignored >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_done
|