mirror of
https://github.com/git/git
synced 2024-11-05 18:59:29 +00:00
2d86a96220
Commit 878f988350 (t/test-lib: teach --chain-lint to detect broken
&&-chains in subshells, 2018-07-11) introduced additional chain-lint
tests which add an extra "sed" pipeline to each test we run. This has a
measurable impact on runtime. Here are timings with and without a new
environment variable (added by this patch) that lets you disable just
the additional sed-based chain-lint tests:
Benchmark #1: GIT_TEST_CHAIN_LINT_HARDER=1 make test
Time (mean ± σ): 64.202 s ± 1.030 s [User: 622.469 s, System: 301.402 s]
Range (min … max): 61.571 s … 65.662 s 10 runs
Benchmark #2: GIT_TEST_CHAIN_LINT_HARDER=0 make test
Time (mean ± σ): 57.591 s ± 0.333 s [User: 529.368 s, System: 270.618 s]
Range (min … max): 57.143 s … 58.309 s 10 runs
Summary
'GIT_TEST_CHAIN_LINT_HARDER=0 make test' ran
1.11 ± 0.02 times faster than 'GIT_TEST_CHAIN_LINT_HARDER=1 make test'
Of course those extra lint checks are doing something useful, so paying
a few extra seconds (at least on Linux) isn't so bad (though note the
CPU time; we're bounded in our parallel run here by the slowest test, so
it really is ~120s of CPU improvement).
But we can observe that there are some test scripts where they produce a
much stronger effect, and provide less value. In t0027 and t3070 we run
a very large number of small tests, all driven by a series of
functions/loops which are filling in the test bodies. There we get much
less bang for our buck in terms of bug-finding versus CPU cost.
This patch introduces a mechanism for controlling when those extra
lint checks are run, at two levels:
- a user can ask to disable or to force-enable the checks by setting
GIT_TEST_CHAIN_LINT_HARDER
- if the user hasn't specified a preference, individual scripts can
disable the checks by setting GIT_TEST_CHAIN_LINT_HARDER_DEFAULT;
scripts which don't set that get the current behavior of enabling
them.
In addition, this patch flips the default for t0027 and t3070's
mass-generated sections to disable the extra checks. Here are the timing
results for t0027:
Benchmark #1: GIT_TEST_CHAIN_LINT_HARDER=1 ./t0027-auto-crlf.sh
Time (mean ± σ): 17.078 s ± 0.848 s [User: 14.878 s, System: 7.075 s]
Range (min … max): 15.952 s … 18.421 s 10 runs
Benchmark #2: GIT_TEST_CHAIN_LINT_HARDER=0 ./t0027-auto-crlf.sh
Time (mean ± σ): 9.063 s ± 0.759 s [User: 7.890 s, System: 3.362 s]
Range (min … max): 7.747 s … 10.619 s 10 runs
Benchmark #3: ./t0027-auto-crlf.sh
Time (mean ± σ): 9.186 s ± 0.881 s [User: 7.957 s, System: 3.427 s]
Range (min … max): 7.796 s … 10.498 s 10 runs
Summary
'GIT_TEST_CHAIN_LINT_HARDER=0 ./t0027-auto-crlf.sh' ran
1.01 ± 0.13 times faster than './t0027-auto-crlf.sh'
1.88 ± 0.18 times faster than 'GIT_TEST_CHAIN_LINT_HARDER=1 ./t0027-auto-crlf.sh'
We can see that disabling the checks for the whole script buys us an
almost 2x speedup. But the new default behavior, disabling them only for
the mass-generated part, gets us most of that speedup (but still leaves
the checks on for further manual tests people might write).
As a side note, I'd caution about comparing runtimes and CPU seconds
between this timing and the earlier "make test" one. In "make test",
we're running a lot of scripts in parallel, so the CPU is throttling
down (and thus a CPU second saved here would count for more during a
parallel run; the same work takes more CPU seconds there).
We get similar results for t3070:
Benchmark #1: GIT_TEST_CHAIN_LINT_HARDER=1 ./t3070-wildmatch.sh
Time (mean ± σ): 20.054 s ± 3.967 s [User: 16.003 s, System: 8.286 s]
Range (min … max): 11.891 s … 23.671 s 10 runs
Benchmark #2: GIT_TEST_CHAIN_LINT_HARDER=0 ./t3070-wildmatch.sh
Time (mean ± σ): 12.399 s ± 2.256 s [User: 7.542 s, System: 5.342 s]
Range (min … max): 9.606 s … 15.727 s 10 runs
Benchmark #3: ./t3070-wildmatch.sh
Time (mean ± σ): 10.726 s ± 3.476 s [User: 6.790 s, System: 4.365 s]
Range (min … max): 5.444 s … 15.376 s 10 runs
Summary
'./t3070-wildmatch.sh' ran
1.16 ± 0.43 times faster than 'GIT_TEST_CHAIN_LINT_HARDER=0 ./t3070-wildmatch.sh'
1.87 ± 0.71 times faster than 'GIT_TEST_CHAIN_LINT_HARDER=1 ./t3070-wildmatch.sh'
Again, we get almost a 2x speedup disabling these. In this case, there
are no tests not covered by the script's "default to disable" behavior,
so the second two benchmarks should be the same (and while they do
differ, you can see the variance is quite high but they're within one
standard deviation).
So it seems like for these two scripts, at least, disabling the extra
checks is a reasonable tradeoff. Sadly, the overall runtime of "make
test" on my system doesn't get much faster. But that's because we're
mostly limited by the cost of the single biggest test. Here are the
top-5 tests by wall-clock time from a parallel run, before my patch:
57.9192368984222 t9001-send-email.sh
45.6329638957977 t0027-auto-crlf.sh
32.5278220176697 t3070-wildmatch.sh
22.2701289653778 t7610-mergetool.sh
20.8635759353638 t1701-racy-split-index.sh
And after:
57.1476998329163 t9001-send-email.sh
33.776211977005 t0027-auto-crlf.sh
21.3116669654846 t7610-mergetool.sh
20.7748689651489 t1701-racy-split-index.sh
19.6957249641418 t7112-reset-submodule.sh
We dropped 12s from t0027, and t3070 dropped off our list entirely at
around 16s. In both cases we're bound by t9001, but its slowness is
due to the actual tests, so we'll have to deal with it in a different
way. But this reduces overall CPU, and means that dealing with t9001 (by
improving the speed of send-email or splitting it apart) will let us
reduce our overall runtime even on multi-core machines.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
620 lines
23 KiB
Bash
Executable file
620 lines
23 KiB
Bash
Executable file
#!/bin/sh
|
|
|
|
test_description='CRLF conversion all combinations'
|
|
|
|
. ./test-lib.sh
|
|
|
|
compare_files () {
|
|
tr '\015\000' QN <"$1" >"$1".expect &&
|
|
tr '\015\000' QN <"$2" | tr -d 'Z' >"$2".actual &&
|
|
test_cmp "$1".expect "$2".actual &&
|
|
rm "$1".expect "$2".actual
|
|
}
|
|
|
|
compare_ws_file () {
|
|
pfx=$1
|
|
exp=$2.expect
|
|
act=$pfx.actual.$3
|
|
tr '\015\000abcdef0123456789' QN00000000000000000 <"$2" |
|
|
sed -e "s/0000*/$ZERO_OID/" >"$exp" &&
|
|
tr '\015\000abcdef0123456789' QN00000000000000000 <"$3" |
|
|
sed -e "s/0000*/$ZERO_OID/" >"$act" &&
|
|
test_cmp "$exp" "$act" &&
|
|
rm "$exp" "$act"
|
|
}
|
|
|
|
create_gitattributes () {
|
|
{
|
|
while test "$#" != 0
|
|
do
|
|
case "$1" in
|
|
auto) echo '*.txt text=auto' ;;
|
|
ident) echo '*.txt ident' ;;
|
|
text) echo '*.txt text' ;;
|
|
-text) echo '*.txt -text' ;;
|
|
crlf) echo '*.txt eol=crlf' ;;
|
|
lf) echo '*.txt eol=lf' ;;
|
|
"") ;;
|
|
*)
|
|
echo >&2 invalid attribute: "$1"
|
|
exit 1
|
|
;;
|
|
esac &&
|
|
shift
|
|
done
|
|
} >.gitattributes
|
|
}
|
|
|
|
# Create 2 sets of files:
|
|
# The NNO files are "Not NOrmalized in the repo. We use CRLF_mix_LF and store
|
|
# it under different names for the different test cases, see ${pfx}
|
|
# Depending on .gitattributes they are normalized at the next commit (or not)
|
|
# The MIX files have different contents in the repo.
|
|
# Depending on its contents, the "new safer autocrlf" may kick in.
|
|
create_NNO_MIX_files () {
|
|
for crlf in false true input
|
|
do
|
|
for attr in "" auto text -text
|
|
do
|
|
for aeol in "" lf crlf
|
|
do
|
|
pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf} &&
|
|
cp CRLF_mix_LF ${pfx}_LF.txt &&
|
|
cp CRLF_mix_LF ${pfx}_CRLF.txt &&
|
|
cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
|
|
cp CRLF_mix_LF ${pfx}_LF_mix_CR.txt &&
|
|
cp CRLF_mix_LF ${pfx}_CRLF_nul.txt &&
|
|
pfx=MIX_attr_${attr}_aeol_${aeol}_${crlf} &&
|
|
cp LF ${pfx}_LF.txt &&
|
|
cp CRLF ${pfx}_CRLF.txt &&
|
|
cp CRLF_mix_LF ${pfx}_CRLF_mix_LF.txt &&
|
|
cp LF_mix_CR ${pfx}_LF_mix_CR.txt &&
|
|
cp CRLF_nul ${pfx}_CRLF_nul.txt
|
|
done
|
|
done
|
|
done
|
|
}
|
|
|
|
check_warning () {
|
|
case "$1" in
|
|
LF_CRLF) echo "warning: LF will be replaced by CRLF" >"$2".expect ;;
|
|
CRLF_LF) echo "warning: CRLF will be replaced by LF" >"$2".expect ;;
|
|
'') >"$2".expect ;;
|
|
*) echo >&2 "Illegal 1": "$1" ; return false ;;
|
|
esac
|
|
grep "will be replaced by" "$2" | sed -e "s/\(.*\) in [^ ]*$/\1/" | uniq >"$2".actual
|
|
test_cmp "$2".expect "$2".actual
|
|
}
|
|
|
|
commit_check_warn () {
|
|
crlf=$1
|
|
attr=$2
|
|
lfname=$3
|
|
crlfname=$4
|
|
lfmixcrlf=$5
|
|
lfmixcr=$6
|
|
crlfnul=$7
|
|
pfx=crlf_${crlf}_attr_${attr}
|
|
create_gitattributes "$attr" &&
|
|
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul CRLF_nul
|
|
do
|
|
fname=${pfx}_$f.txt &&
|
|
cp $f $fname &&
|
|
git -c core.autocrlf=$crlf add $fname 2>"${pfx}_$f.err"
|
|
done &&
|
|
git commit -m "core.autocrlf $crlf" &&
|
|
check_warning "$lfname" ${pfx}_LF.err &&
|
|
check_warning "$crlfname" ${pfx}_CRLF.err &&
|
|
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err &&
|
|
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err &&
|
|
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
|
|
}
|
|
|
|
commit_chk_wrnNNO () {
|
|
attr=$1 ; shift
|
|
aeol=$1 ; shift
|
|
crlf=$1 ; shift
|
|
lfwarn=$1 ; shift
|
|
crlfwarn=$1 ; shift
|
|
lfmixcrlf=$1 ; shift
|
|
lfmixcr=$1 ; shift
|
|
crlfnul=$1 ; shift
|
|
pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
|
|
#Commit files on top of existing file
|
|
create_gitattributes "$attr" $aeol &&
|
|
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
do
|
|
fname=${pfx}_$f.txt &&
|
|
cp $f $fname &&
|
|
printf Z >>"$fname" &&
|
|
git -c core.autocrlf=$crlf add $fname 2>"${pfx}_$f.err"
|
|
done
|
|
|
|
test_expect_success "commit NNO files crlf=$crlf attr=$attr LF" '
|
|
check_warning "$lfwarn" ${pfx}_LF.err
|
|
'
|
|
test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF" '
|
|
check_warning "$crlfwarn" ${pfx}_CRLF.err
|
|
'
|
|
|
|
test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_mix_LF" '
|
|
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
|
|
'
|
|
|
|
test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf LF_mix_cr" '
|
|
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
|
|
'
|
|
|
|
test_expect_success "commit NNO files attr=$attr aeol=$aeol crlf=$crlf CRLF_nul" '
|
|
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
|
|
'
|
|
}
|
|
|
|
# Commit a file with mixed line endings on top of different files
|
|
# in the index. Check for warnings
|
|
commit_MIX_chkwrn () {
|
|
attr=$1 ; shift
|
|
aeol=$1 ; shift
|
|
crlf=$1 ; shift
|
|
lfwarn=$1 ; shift
|
|
crlfwarn=$1 ; shift
|
|
lfmixcrlf=$1 ; shift
|
|
lfmixcr=$1 ; shift
|
|
crlfnul=$1 ; shift
|
|
pfx=MIX_attr_${attr}_aeol_${aeol}_${crlf}
|
|
#Commit file with CLRF_mix_LF on top of existing file
|
|
create_gitattributes "$attr" $aeol &&
|
|
for f in LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
do
|
|
fname=${pfx}_$f.txt &&
|
|
cp CRLF_mix_LF $fname &&
|
|
printf Z >>"$fname" &&
|
|
git -c core.autocrlf=$crlf add $fname 2>"${pfx}_$f.err"
|
|
done
|
|
|
|
test_expect_success "commit file with mixed EOL onto LF crlf=$crlf attr=$attr" '
|
|
check_warning "$lfwarn" ${pfx}_LF.err
|
|
'
|
|
test_expect_success "commit file with mixed EOL onto CLRF attr=$attr aeol=$aeol crlf=$crlf" '
|
|
check_warning "$crlfwarn" ${pfx}_CRLF.err
|
|
'
|
|
|
|
test_expect_success "commit file with mixed EOL onto CRLF_mix_LF attr=$attr aeol=$aeol crlf=$crlf" '
|
|
check_warning "$lfmixcrlf" ${pfx}_CRLF_mix_LF.err
|
|
'
|
|
|
|
test_expect_success "commit file with mixed EOL onto LF_mix_cr attr=$attr aeol=$aeol crlf=$crlf " '
|
|
check_warning "$lfmixcr" ${pfx}_LF_mix_CR.err
|
|
'
|
|
|
|
test_expect_success "commit file with mixed EOL onto CRLF_nul attr=$attr aeol=$aeol crlf=$crlf" '
|
|
check_warning "$crlfnul" ${pfx}_CRLF_nul.err
|
|
'
|
|
}
|
|
|
|
|
|
stats_ascii () {
|
|
case "$1" in
|
|
LF)
|
|
echo lf
|
|
;;
|
|
CRLF)
|
|
echo crlf
|
|
;;
|
|
CRLF_mix_LF)
|
|
echo mixed
|
|
;;
|
|
LF_mix_CR|CRLF_nul|LF_nul|CRLF_mix_CR)
|
|
echo "-text"
|
|
;;
|
|
*)
|
|
echo error_invalid $1
|
|
;;
|
|
esac
|
|
|
|
}
|
|
|
|
|
|
# construct the attr/ returned by git ls-files --eol
|
|
# Take none (=empty), one or two args
|
|
# convert.c: eol=XX overrides text=auto
|
|
attr_ascii () {
|
|
case $1,$2 in
|
|
-text,*) echo "-text" ;;
|
|
text,) echo "text" ;;
|
|
text,lf) echo "text eol=lf" ;;
|
|
text,crlf) echo "text eol=crlf" ;;
|
|
auto,) echo "text=auto" ;;
|
|
auto,lf) echo "text=auto eol=lf" ;;
|
|
auto,crlf) echo "text=auto eol=crlf" ;;
|
|
lf,) echo "text eol=lf" ;;
|
|
crlf,) echo "text eol=crlf" ;;
|
|
,) echo "" ;;
|
|
*) echo invalid_attr "$1,$2" ;;
|
|
esac
|
|
}
|
|
|
|
check_files_in_repo () {
|
|
crlf=$1
|
|
attr=$2
|
|
lfname=$3
|
|
crlfname=$4
|
|
lfmixcrlf=$5
|
|
lfmixcr=$6
|
|
crlfnul=$7
|
|
pfx=crlf_${crlf}_attr_${attr}_ &&
|
|
compare_files $lfname ${pfx}LF.txt &&
|
|
compare_files $crlfname ${pfx}CRLF.txt &&
|
|
compare_files $lfmixcrlf ${pfx}CRLF_mix_LF.txt &&
|
|
compare_files $lfmixcr ${pfx}LF_mix_CR.txt &&
|
|
compare_files $crlfnul ${pfx}CRLF_nul.txt
|
|
}
|
|
|
|
check_in_repo_NNO () {
|
|
attr=$1 ; shift
|
|
aeol=$1 ; shift
|
|
crlf=$1 ; shift
|
|
lfname=$1 ; shift
|
|
crlfname=$1 ; shift
|
|
lfmixcrlf=$1 ; shift
|
|
lfmixcr=$1 ; shift
|
|
crlfnul=$1 ; shift
|
|
pfx=NNO_attr_${attr}_aeol_${aeol}_${crlf}
|
|
test_expect_success "compare_files $lfname ${pfx}_LF.txt" '
|
|
compare_files $lfname ${pfx}_LF.txt
|
|
'
|
|
test_expect_success "compare_files $crlfname ${pfx}_CRLF.txt" '
|
|
compare_files $crlfname ${pfx}_CRLF.txt
|
|
'
|
|
test_expect_success "compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt" '
|
|
compare_files $lfmixcrlf ${pfx}_CRLF_mix_LF.txt
|
|
'
|
|
test_expect_success "compare_files $lfmixcr ${pfx}_LF_mix_CR.txt" '
|
|
compare_files $lfmixcr ${pfx}_LF_mix_CR.txt
|
|
'
|
|
test_expect_success "compare_files $crlfnul ${pfx}_CRLF_nul.txt" '
|
|
compare_files $crlfnul ${pfx}_CRLF_nul.txt
|
|
'
|
|
}
|
|
|
|
checkout_files () {
|
|
attr=$1 ; shift
|
|
ident=$1; shift
|
|
aeol=$1 ; shift
|
|
crlf=$1 ; shift
|
|
ceol=$1 ; shift
|
|
lfname=$1 ; shift
|
|
crlfname=$1 ; shift
|
|
lfmixcrlf=$1 ; shift
|
|
lfmixcr=$1 ; shift
|
|
crlfnul=$1 ; shift
|
|
create_gitattributes "$attr" $ident $aeol &&
|
|
git config core.autocrlf $crlf &&
|
|
pfx=eol_${ceol}_crlf_${crlf}_attr_${attr}_ &&
|
|
for f in LF CRLF LF_mix_CR CRLF_mix_LF LF_nul
|
|
do
|
|
rm crlf_false_attr__$f.txt &&
|
|
if test -z "$ceol"; then
|
|
git checkout -- crlf_false_attr__$f.txt
|
|
else
|
|
git -c core.eol=$ceol checkout -- crlf_false_attr__$f.txt
|
|
fi
|
|
done
|
|
|
|
test_expect_success "ls-files --eol attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol" '
|
|
test_when_finished "rm expect actual" &&
|
|
sort <<-EOF >expect &&
|
|
i/crlf w/$(stats_ascii $crlfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF.txt
|
|
i/mixed w/$(stats_ascii $lfmixcrlf) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF_mix_LF.txt
|
|
i/lf w/$(stats_ascii $lfname) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF.txt
|
|
i/-text w/$(stats_ascii $lfmixcr) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF_mix_CR.txt
|
|
i/-text w/$(stats_ascii $crlfnul) attr/$(attr_ascii $attr $aeol) crlf_false_attr__CRLF_nul.txt
|
|
i/-text w/$(stats_ascii $crlfnul) attr/$(attr_ascii $attr $aeol) crlf_false_attr__LF_nul.txt
|
|
EOF
|
|
git ls-files --eol crlf_false_attr__* |
|
|
sed -e "s/ / /g" -e "s/ */ /g" |
|
|
sort >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF" "
|
|
compare_ws_file $pfx $lfname crlf_false_attr__LF.txt
|
|
"
|
|
test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF" "
|
|
compare_ws_file $pfx $crlfname crlf_false_attr__CRLF.txt
|
|
"
|
|
test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=CRLF_mix_LF" "
|
|
compare_ws_file $pfx $lfmixcrlf crlf_false_attr__CRLF_mix_LF.txt
|
|
"
|
|
test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_mix_CR" "
|
|
compare_ws_file $pfx $lfmixcr crlf_false_attr__LF_mix_CR.txt
|
|
"
|
|
test_expect_success "checkout attr=$attr $ident aeol=$aeol core.autocrlf=$crlf core.eol=$ceol file=LF_nul" "
|
|
compare_ws_file $pfx $crlfnul crlf_false_attr__LF_nul.txt
|
|
"
|
|
}
|
|
|
|
# Test control characters
|
|
# NUL SOH CR EOF==^Z
|
|
test_expect_success 'ls-files --eol -o Text/Binary' '
|
|
test_when_finished "rm expect actual TeBi_*" &&
|
|
STRT=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA &&
|
|
STR=$STRT$STRT$STRT$STRT &&
|
|
printf "${STR}BBB\001" >TeBi_127_S &&
|
|
printf "${STR}BBBB\001">TeBi_128_S &&
|
|
printf "${STR}BBB\032" >TeBi_127_E &&
|
|
printf "\032${STR}BBB" >TeBi_E_127 &&
|
|
printf "${STR}BBBB\000">TeBi_128_N &&
|
|
printf "${STR}BBB\012">TeBi_128_L &&
|
|
printf "${STR}BBB\015">TeBi_127_C &&
|
|
printf "${STR}BB\015\012" >TeBi_126_CL &&
|
|
printf "${STR}BB\015\012\015" >TeBi_126_CLC &&
|
|
sort <<-\EOF >expect &&
|
|
i/ w/-text TeBi_127_S
|
|
i/ w/none TeBi_128_S
|
|
i/ w/none TeBi_127_E
|
|
i/ w/-text TeBi_E_127
|
|
i/ w/-text TeBi_128_N
|
|
i/ w/lf TeBi_128_L
|
|
i/ w/-text TeBi_127_C
|
|
i/ w/crlf TeBi_126_CL
|
|
i/ w/-text TeBi_126_CLC
|
|
EOF
|
|
git ls-files --eol -o |
|
|
sed -n -e "/TeBi_/{s!attr/[ ]*!!g
|
|
s! ! !g
|
|
s! *! !g
|
|
p
|
|
}" | sort >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_expect_success 'setup main' '
|
|
echo >.gitattributes &&
|
|
git checkout -b main &&
|
|
git add .gitattributes &&
|
|
git commit -m "add .gitattributes" . &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\nLINETWO\nLINETHREE" >LF &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONE\r\nLINETWO\r\nLINETHREE" >CRLF &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\r\nLINETWO\nLINETHREE" >CRLF_mix_LF &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONE\nLINETWO\rLINETHREE" >LF_mix_CR &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONE\r\nLINETWO\rLINETHREE" >CRLF_mix_CR &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\r\nLINEONEQ\r\nLINETWO\r\nLINETHREE" | q_to_nul >CRLF_nul &&
|
|
printf "\$Id: 0000000000000000000000000000000000000000 \$\nLINEONEQ\nLINETWO\nLINETHREE" | q_to_nul >LF_nul &&
|
|
create_NNO_MIX_files &&
|
|
git -c core.autocrlf=false add NNO_*.txt MIX_*.txt &&
|
|
git commit -m "mixed line endings" &&
|
|
test_tick
|
|
'
|
|
|
|
# Disable extra chain-linting for the next set of tests. There are many
|
|
# auto-generated ones that are not worth checking over and over.
|
|
GIT_TEST_CHAIN_LINT_HARDER_DEFAULT=0
|
|
|
|
warn_LF_CRLF="LF will be replaced by CRLF"
|
|
warn_CRLF_LF="CRLF will be replaced by LF"
|
|
|
|
# WILC stands for "Warn if (this OS) converts LF into CRLF".
|
|
# WICL: Warn if CRLF becomes LF
|
|
# WAMIX: Mixed line endings: either CRLF->LF or LF->CRLF
|
|
if test_have_prereq NATIVE_CRLF
|
|
then
|
|
WILC=LF_CRLF
|
|
WICL=
|
|
WAMIX=LF_CRLF
|
|
else
|
|
WILC=
|
|
WICL=CRLF_LF
|
|
WAMIX=CRLF_LF
|
|
fi
|
|
|
|
# attr LF CRLF CRLFmixLF LFmixCR CRLFNUL
|
|
test_expect_success 'commit files empty attr' '
|
|
commit_check_warn false "" "" "" "" "" "" &&
|
|
commit_check_warn true "" "LF_CRLF" "" "LF_CRLF" "" "" &&
|
|
commit_check_warn input "" "" "CRLF_LF" "CRLF_LF" "" ""
|
|
'
|
|
|
|
test_expect_success 'commit files attr=auto' '
|
|
commit_check_warn false "auto" "$WILC" "$WICL" "$WAMIX" "" "" &&
|
|
commit_check_warn true "auto" "LF_CRLF" "" "LF_CRLF" "" "" &&
|
|
commit_check_warn input "auto" "" "CRLF_LF" "CRLF_LF" "" ""
|
|
'
|
|
|
|
test_expect_success 'commit files attr=text' '
|
|
commit_check_warn false "text" "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL" &&
|
|
commit_check_warn true "text" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" "" &&
|
|
commit_check_warn input "text" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
|
|
'
|
|
|
|
test_expect_success 'commit files attr=-text' '
|
|
commit_check_warn false "-text" "" "" "" "" "" &&
|
|
commit_check_warn true "-text" "" "" "" "" "" &&
|
|
commit_check_warn input "-text" "" "" "" "" ""
|
|
'
|
|
|
|
test_expect_success 'commit files attr=lf' '
|
|
commit_check_warn false "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF" &&
|
|
commit_check_warn true "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF" &&
|
|
commit_check_warn input "lf" "" "CRLF_LF" "CRLF_LF" "" "CRLF_LF"
|
|
'
|
|
|
|
test_expect_success 'commit files attr=crlf' '
|
|
commit_check_warn false "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" "" &&
|
|
commit_check_warn true "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" "" &&
|
|
commit_check_warn input "crlf" "LF_CRLF" "" "LF_CRLF" "LF_CRLF" ""
|
|
'
|
|
|
|
# Commit "CRLFmixLF" on top of these files already in the repo:
|
|
# mixed mixed mixed mixed mixed
|
|
# onto onto onto onto onto
|
|
# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
|
|
commit_MIX_chkwrn "" "" false "" "" "" "" ""
|
|
commit_MIX_chkwrn "" "" true "LF_CRLF" "" "" "LF_CRLF" "LF_CRLF"
|
|
commit_MIX_chkwrn "" "" input "CRLF_LF" "" "" "CRLF_LF" "CRLF_LF"
|
|
|
|
commit_MIX_chkwrn "auto" "" false "$WAMIX" "" "" "$WAMIX" "$WAMIX"
|
|
commit_MIX_chkwrn "auto" "" true "LF_CRLF" "" "" "LF_CRLF" "LF_CRLF"
|
|
commit_MIX_chkwrn "auto" "" input "CRLF_LF" "" "" "CRLF_LF" "CRLF_LF"
|
|
|
|
# attr LF CRLF CRLFmixLF LF_mix_CR CRLFNUL
|
|
commit_chk_wrnNNO "" "" false "" "" "" "" ""
|
|
commit_chk_wrnNNO "" "" true LF_CRLF "" "" "" ""
|
|
commit_chk_wrnNNO "" "" input "" "" "" "" ""
|
|
|
|
commit_chk_wrnNNO "auto" "" false "$WILC" "" "" "" ""
|
|
commit_chk_wrnNNO "auto" "" true LF_CRLF "" "" "" ""
|
|
commit_chk_wrnNNO "auto" "" input "" "" "" "" ""
|
|
for crlf in true false input
|
|
do
|
|
commit_chk_wrnNNO -text "" $crlf "" "" "" "" ""
|
|
commit_chk_wrnNNO -text lf $crlf "" "" "" "" ""
|
|
commit_chk_wrnNNO -text crlf $crlf "" "" "" "" ""
|
|
commit_chk_wrnNNO "" lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
|
|
commit_chk_wrnNNO "" crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
|
|
commit_chk_wrnNNO auto lf $crlf "" "" "" "" ""
|
|
commit_chk_wrnNNO auto crlf $crlf LF_CRLF "" "" "" ""
|
|
commit_chk_wrnNNO text lf $crlf "" CRLF_LF CRLF_LF "" CRLF_LF
|
|
commit_chk_wrnNNO text crlf $crlf LF_CRLF "" LF_CRLF LF_CRLF ""
|
|
done
|
|
|
|
commit_chk_wrnNNO "text" "" false "$WILC" "$WICL" "$WAMIX" "$WILC" "$WICL"
|
|
commit_chk_wrnNNO "text" "" true LF_CRLF "" LF_CRLF LF_CRLF ""
|
|
commit_chk_wrnNNO "text" "" input "" CRLF_LF CRLF_LF "" CRLF_LF
|
|
|
|
test_expect_success 'commit NNO and cleanup' '
|
|
git commit -m "commit files on top of NNO" &&
|
|
rm -f *.txt &&
|
|
git -c core.autocrlf=false reset --hard
|
|
'
|
|
|
|
test_expect_success 'commit empty gitattribues' '
|
|
check_files_in_repo false "" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo true "" LF LF LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo input "" LF LF LF LF_mix_CR CRLF_nul
|
|
'
|
|
|
|
test_expect_success 'commit text=auto' '
|
|
check_files_in_repo false "auto" LF LF LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo true "auto" LF LF LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo input "auto" LF LF LF LF_mix_CR CRLF_nul
|
|
'
|
|
|
|
test_expect_success 'commit text' '
|
|
check_files_in_repo false "text" LF LF LF LF_mix_CR LF_nul &&
|
|
check_files_in_repo true "text" LF LF LF LF_mix_CR LF_nul &&
|
|
check_files_in_repo input "text" LF LF LF LF_mix_CR LF_nul
|
|
'
|
|
|
|
test_expect_success 'commit -text' '
|
|
check_files_in_repo false "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo true "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul &&
|
|
check_files_in_repo input "-text" LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
'
|
|
|
|
for crlf in true false input
|
|
do
|
|
# attr aeol LF CRLF CRLF_mix_LF LF_mix_CR CRLFNUL
|
|
check_in_repo_NNO "" "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO -text "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO -text lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO -text crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO auto "" $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO auto lf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO auto crlf $crlf LF CRLF CRLF_mix_LF LF_mix_CR CRLF_nul
|
|
check_in_repo_NNO text "" $crlf LF LF LF LF_mix_CR LF_nul
|
|
check_in_repo_NNO text lf $crlf LF LF LF LF_mix_CR LF_nul
|
|
check_in_repo_NNO text crlf $crlf LF LF LF LF_mix_CR LF_nul
|
|
done
|
|
################################################################################
|
|
# Check how files in the repo are changed when they are checked out
|
|
# How to read the table below:
|
|
# - checkout_files will check multiple files with a combination of settings
|
|
# and attributes (core.autocrlf=input is forbidden with core.eol=crlf)
|
|
#
|
|
# - parameter $1 : text in .gitattributs "" (empty) | auto | text | -text
|
|
# - parameter $2 : ident "" | i (i == ident)
|
|
# - parameter $3 : eol in .gitattributs "" (empty) | lf | crlf
|
|
# - parameter $4 : core.autocrlf false | true | input
|
|
# - parameter $5 : core.eol "" | lf | crlf | "native"
|
|
# - parameter $6 : reference for a file with only LF in the repo
|
|
# - parameter $7 : reference for a file with only CRLF in the repo
|
|
# - parameter $8 : reference for a file with mixed LF and CRLF in the repo
|
|
# - parameter $9 : reference for a file with LF and CR in the repo
|
|
# - parameter $10 : reference for a file with CRLF and a NUL (should be handled as binary when auto)
|
|
|
|
if test_have_prereq NATIVE_CRLF
|
|
then
|
|
MIX_CRLF_LF=CRLF
|
|
MIX_LF_CR=CRLF_mix_CR
|
|
NL=CRLF
|
|
LFNUL=CRLF_nul
|
|
else
|
|
MIX_CRLF_LF=CRLF_mix_LF
|
|
MIX_LF_CR=LF_mix_CR
|
|
NL=LF
|
|
LFNUL=LF_nul
|
|
fi
|
|
export CRLF_MIX_LF_CR MIX NL
|
|
|
|
# Same handling with and without ident
|
|
for id in "" ident
|
|
do
|
|
for ceol in lf crlf native
|
|
do
|
|
for crlf in true false input
|
|
do
|
|
# -text overrides core.autocrlf and core.eol
|
|
# text and eol=crlf or eol=lf override core.autocrlf and core.eol
|
|
checkout_files -text "$id" "" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files -text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files -text "$id" "crlf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
# text
|
|
checkout_files text "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files text "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
|
|
# currently the same as text, eol=XXX
|
|
checkout_files auto "$id" "lf" "$crlf" "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files auto "$id" "crlf" "$crlf" "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
done
|
|
|
|
# core.autocrlf false, different core.eol
|
|
checkout_files "" "$id" "" false "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
# core.autocrlf true
|
|
checkout_files "" "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
# text: core.autocrlf = true overrides core.eol
|
|
checkout_files auto "$id" "" true "$ceol" CRLF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files text "$id" "" true "$ceol" CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
|
|
# text: core.autocrlf = input overrides core.eol
|
|
checkout_files text "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files auto "$id" "" input "$ceol" LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
# text=auto + eol=XXX
|
|
done
|
|
# text: core.autocrlf=false uses core.eol
|
|
checkout_files text "$id" "" false crlf CRLF CRLF CRLF CRLF_mix_CR CRLF_nul
|
|
checkout_files text "$id" "" false lf LF CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
# text: core.autocrlf=false and core.eol unset(or native) uses native eol
|
|
checkout_files text "$id" "" false "" $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
|
|
checkout_files text "$id" "" false native $NL CRLF $MIX_CRLF_LF $MIX_LF_CR $LFNUL
|
|
# auto: core.autocrlf=false and core.eol unset(or native) uses native eol
|
|
checkout_files auto "$id" "" false "" $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
checkout_files auto "$id" "" false native $NL CRLF CRLF_mix_LF LF_mix_CR LF_nul
|
|
done
|
|
|
|
# The rest of the tests are unique; do the usual linting.
|
|
unset GIT_TEST_CHAIN_LINT_HARDER_DEFAULT
|
|
|
|
# Should be the last test case: remove some files from the worktree
|
|
test_expect_success 'ls-files --eol -d -z' '
|
|
rm crlf_false_attr__CRLF.txt crlf_false_attr__CRLF_mix_LF.txt crlf_false_attr__LF.txt .gitattributes &&
|
|
cat >expect <<-\EOF &&
|
|
i/crlf w/ crlf_false_attr__CRLF.txt
|
|
i/lf w/ .gitattributes
|
|
i/lf w/ crlf_false_attr__LF.txt
|
|
i/mixed w/ crlf_false_attr__CRLF_mix_LF.txt
|
|
EOF
|
|
git ls-files --eol -d |
|
|
sed -e "s!attr/[^ ]*!!g" -e "s/ / /g" -e "s/ */ /g" |
|
|
sort >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_done
|