1
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-10-30 13:57:54 +01:00
git/t/t0081-line-buffer.sh
Jeff King a892a2ddfe tests: kill backgrounded processes more robustly
t0081 creates several background processes that write to a fifo and
then go to sleep for a while (so the reader of the fifo does not see
EOF).

Each background process is made in a curly-braced block in the shell,
and after we are done reading from the fifo, we use "kill $!" to kill
it off.

For a simple, single-command process, this works reliably and kills
the child sleep process. But for more complex commands like
"make_some_output && sleep", the results are less predictable. When
executing under bash, we end up with a subshell that gets killed by
the $! but leaves the sleep process still alive.

This is bad not only for process hygeine (we are leaving random sleep
processes to expire after a while), but also interacts badly with the
"prove" command. When prove executes a test, it does not realize the
test is done when it sees SIGCHLD, but rather waits until the test's
stdout pipe is closed. The orphaned sleep process may keep that pipe
open via test-lib's file descriptor 5, causing prove to hang for 100
seconds.

The solution is to explicitly use a subshell and to exec the final
sleep process, so that when we "kill $!" we get the process id of the
sleep process.

[jn: original patch by Jeff had some additional bits:

   1. Wrap the "kill" in a test_when_finished, since we want
      to clean up the process whether the test succeeds or not.

   2. The "kill" is part of our && chain for test success. It
      probably won't fail, but it can if the process has
      expired before we manage to kill it. So let's mark it
      as OK to fail.

 I'm postponing that for now.]

Reported-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Jonathan Nieder <jrnieder@gmail.com>
2011-03-29 23:18:27 -05:00

192 lines
3.5 KiB
Bash
Executable file

#!/bin/sh
test_description="Test the svn importer's input handling routines.
These tests exercise the line_buffer library, but their real purpose
is to check the assumptions that library makes of the platform's input
routines. Processes engaged in bi-directional communication would
hang if fread or fgets is too greedy.
While at it, check that input of newlines and null bytes are handled
correctly.
"
. ./test-lib.sh
test -n "$GIT_REMOTE_SVN_TEST_BIG_FILES" && test_set_prereq EXPENSIVE
generate_tens_of_lines () {
tens=$1 &&
line=$2 &&
i=0 &&
while test $i -lt "$tens"
do
for j in a b c d e f g h i j
do
echo "$line"
done &&
: $((i = $i + 1)) ||
return
done
}
long_read_test () {
: each line is 10 bytes, including newline &&
line=abcdefghi &&
echo "$line" >expect &&
if ! test_declared_prereq PIPE
then
echo >&4 "long_read_test: need to declare PIPE prerequisite"
return 127
fi &&
tens_of_lines=$(($1 / 100 + 1)) &&
lines=$(($tens_of_lines * 10)) &&
readsize=$((($lines - 1) * 10 + 3)) &&
copysize=7 &&
rm -f input &&
mkfifo input &&
{
(
generate_tens_of_lines $tens_of_lines "$line" &&
exec sleep 100
) >input &
} &&
test-line-buffer input <<-EOF >output &&
binary $readsize
copy $copysize
EOF
kill $! &&
test_line_count = $lines output &&
tail -n 1 <output >actual &&
test_cmp expect actual
}
test_expect_success 'setup: have pipes?' '
rm -f frob &&
if mkfifo frob
then
test_set_prereq PIPE
fi
'
test_expect_success 'hello world' '
echo ">HELLO" >expect &&
test-line-buffer <<-\EOF >actual &&
binary 6
HELLO
EOF
test_cmp expect actual
'
test_expect_success PIPE '0-length read, no input available' '
printf ">" >expect &&
rm -f input &&
mkfifo input &&
{
sleep 100 >input &
} &&
test-line-buffer input <<-\EOF >actual &&
binary 0
copy 0
EOF
kill $! &&
test_cmp expect actual
'
test_expect_success '0-length read, send along greeting' '
echo ">HELLO" >expect &&
test-line-buffer <<-\EOF >actual &&
binary 0
copy 6
HELLO
EOF
test_cmp expect actual
'
test_expect_success PIPE '1-byte read, no input available' '
printf ">%s" ab >expect &&
rm -f input &&
mkfifo input &&
{
(
printf "%s" a &&
printf "%s" b &&
exec sleep 100
) >input &
} &&
test-line-buffer input <<-\EOF >actual &&
binary 1
copy 1
EOF
kill $! &&
test_cmp expect actual
'
test_expect_success PIPE 'long read (around 8192 bytes)' '
long_read_test 8192
'
test_expect_success PIPE,EXPENSIVE 'longer read (around 65536 bytes)' '
long_read_test 65536
'
test_expect_success 'read from file descriptor' '
rm -f input &&
echo hello >expect &&
echo hello >input &&
echo copy 6 |
test-line-buffer "&4" 4<input >actual &&
test_cmp expect actual
'
test_expect_success 'skip, copy null byte' '
echo Q | q_to_nul >expect &&
q_to_nul <<-\EOF | test-line-buffer >actual &&
skip 2
Q
copy 2
Q
EOF
test_cmp expect actual
'
test_expect_success 'read null byte' '
echo ">QhelloQ" | q_to_nul >expect &&
q_to_nul <<-\EOF | test-line-buffer >actual &&
binary 8
QhelloQ
EOF
test_cmp expect actual
'
test_expect_success 'long reads are truncated' '
echo ">foo" >expect &&
test-line-buffer <<-\EOF >actual &&
binary 5
foo
EOF
test_cmp expect actual
'
test_expect_success 'long copies are truncated' '
printf "%s\n" ">" foo >expect &&
test-line-buffer <<-\EOF >actual &&
binary 1
copy 5
foo
EOF
test_cmp expect actual
'
test_expect_success 'long binary reads are truncated' '
echo ">foo" >expect &&
test-line-buffer <<-\EOF >actual &&
binary 5
foo
EOF
test_cmp expect actual
'
test_done