mirrors/pv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrote most of run-test, and gave variables clearer names

Browse Source
This commit is contained in:
Andrew Wood
2023-07-23 14:54:45 +01:00
parent a0e5d5e9e7
commit b086ddf599
24 changed files with 245 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files
autoconf/scripts/run-test.sh
+114 -54
View File
@@ -1,73 +1,133 @@
#!/bin/sh
#
# Run a test. Parameters are program name and source directory; if
# additional parameters are given, they are the tests to run, otherwise all
# tests are run.
# Parameters: testSubject sourcePath [testScript...]
#
# Test scripts should exit 0 if the test passed.
# Run one or more test scripts. The ${testSubject} is the path of the test
# subject program, and the ${sourcePath} is the path to the top level of the
# source directory. If any ${testScript} parameters are given, they are the
# tests to run (each one being either the full path to a script, or the base
# filename of the script in the test directory). If no test scripts are
# listed, then all tests directly under "${sourcePath}/tests/" are run.
#
# If a test exits with status 2, it is listed as being skipped.
# Test scripts should be written to exit 0 if the test passed, 2 if the test
# is to be skipped, or any other exit status to indicate failure.
#
# Anything output by a test script on stdout or stderr is captured and shown
# after the "OK"/"FAILED"/"skipped" status.
# after the "OK" / "FAILED" / "skipped" result description.
#
# The exit status of this script will be 1 if any test failed, 0 otherwise.
# A skipped test is not counted as a failure.
#
PROG="$1"
SRCDIR="$2"
testSubject="$1"
sourcePath="$2"
shift
shift
TESTS="$*"
selectedTests="$*"
# Temporary working files
# Temporary working files, for the test scripts to use.
workFile1=$(mktemp 2>/dev/null) || workFile1="./.tmp1"
workFile2=$(mktemp 2>/dev/null) || workFile2="./.tmp2"
workFile3=$(mktemp 2>/dev/null) || workFile3="./.tmp3"
workFile4=$(mktemp 2>/dev/null) || workFile4="./.tmp4"
# Clean up the temporary files on exit, in case we are interrupted.
trap 'rm -f "${workFile1}" "${workFile2}" "${workFile3}" "${workFile4}"' EXIT
# Variables used by the test scripts.
export testSubject workFile1 workFile2 workFile3 workFile4
# If no tests were specified, list all test scripts under the source path.
test -n "${selectedTests}" || selectedTests=$(find "${sourcePath}/tests" -maxdepth 1 -type f | sort -n)
# Initial pass to count the number of tests and find the length of the
# longest test name, to use when formatting the output.
#
TMP1=$(mktemp 2>/dev/null) || TMP1=.tmp1
TMP2=$(mktemp 2>/dev/null) || TMP2=.tmp2
TMP3=$(mktemp 2>/dev/null) || TMP3=.tmp3
TMP4=$(mktemp 2>/dev/null) || TMP4=.tmp4
numberOfTests=0
maxTestNameLength=0
for testScript in ${selectedTests}; do
# Find the test script, make sure it exists.
test -f "${testScript}" || testScript="${sourcePath}/tests/${testScript}"
test -f "${testScript}" || testScript=$(find "${sourcePath}/tests" -maxdepth 1 -type f -name "${testScript}*" | sed -n '1p')
test -f "${testScript}" || continue
trap "rm -f ${TMP1} ${TMP2} ${TMP3} ${TMP4}" EXIT
numberOfTests=$((1+numberOfTests))
export PROG TMP1 TMP2 TMP3 TMP4 # variables used by test scripts
FAIL=0
test -n "$TESTS" || TESTS=$(ls "$SRCDIR/tests" | sort -n)
MAXNAMESIZE=$(echo "$TESTS" | tr ' ' '\n' | sed 's,^.*/,,;s/-/ - /' | awk 'BEGIN{m=0} {n=length($0);if (n>m) m=n} END{print m}')
test -n "$MAXNAMESIZE" || MAXNAMESIZE=1
test "$MAXNAMESIZE" -lt 10 && MAXNAMESIZE=10
test "$MAXNAMESIZE" -gt 60 && MAXNAMESIZE=60
for SCRIPT in $TESTS; do
test -f "$SCRIPT" || SCRIPT="$SRCDIR/tests/$SCRIPT"
test -f "$SCRIPT" || SCRIPT=$(ls "$SRCDIR/tests/$SCRIPT"*)
test -f "$SCRIPT" || continue
printf "%-${MAXNAMESIZE}.${MAXNAMESIZE}s " "$(echo "${SCRIPT}" | sed 's,^.*/,,;s/-/ - /')"
TESTEXITSTATUS=0
TESTOUTPUT=""
TESTOUTPUT=$(sh -e "$SCRIPT" 2>&1)
TESTEXITSTATUS=$?
TESTRESULT=""
if test $TESTEXITSTATUS -eq 0; then
TESTRESULT="OK"
elif test $TESTEXITSTATUS -eq 2; then
TESTRESULT="skipped"
else
TESTRESULT="FAILED"
FAIL=1
fi
test -n "${TESTOUTPUT}" && TESTOUTPUT=" - ${TESTOUTPUT}"
printf "%s%s\n" "${TESTRESULT}" "${TESTOUTPUT}"
testScriptLeaf="${testScript##*/}"
testName="$(echo "${testScriptLeaf}" | sed 's/-/ - /' | tr '_' ' ')"
testNameLength=${#testName}
test "${testNameLength}" -gt "${maxTestNameLength}" && maxTestNameLength="${testNameLength}"
done
rm -f "$TMP1" "$TMP2" "$TMP3" "$TMP4"
trap "" EXIT
# Set a minimum and maximum test name length.
test "${maxTestNameLength}" -lt 10 && maxTestNameLength=10
test "${maxTestNameLength}" -gt 60 && maxTestNameLength=60
exit $FAIL
# Count the number of digits in the number of tests so we know how wide the
# column for the test count should be.
testCountWidth=${#numberOfTests}
# The exit status - 0 means all tests that were run have passed, 1 means
# that at least one test failed.
overallExitStatus=0
# Run all of the selected test scripts, formatting the output.
#
testNumber=0
for testScript in ${selectedTests}; do
# Find the test script, make sure it exists.
test -f "${testScript}" || testScript="${sourcePath}/tests/${testScript}"
test -f "${testScript}" || testScript=$(find "${sourcePath}/tests" -maxdepth 1 -type f -name "${testScript}*" | sed -n '1p')
test -f "${testScript}" || continue
testNumber=$((1+testNumber))
testScriptLeaf="${testScript##*/}"
testName="$(echo "${testScriptLeaf}" | sed 's/-/ - /' | tr '_' ' ')"
printf "%${testCountWidth}d/%d: %-${maxTestNameLength}.${maxTestNameLength}s " "${testNumber}" "${numberOfTests}" "${testName}"
# Run the test script, capturing the output and the exit status.
testExitStatus=0
testOutput=""
testOutput=$(sh -e "${testScript}" 2>&1)
testExitStatus=$?
# Work out what we're going to say about this test result.
testResultDescription=""
resultFormatCodes=""
if test ${testExitStatus} -eq 0; then
resultFormatCodes="setaf 2;bold"
testResultDescription="OK"
elif test ${testExitStatus} -eq 2; then
resultFormatCodes="setaf 3"
testResultDescription="skipped"
else
resultFormatCodes="setaf 1;bold"
testResultDescription="FAILED"
overallExitStatus=1
fi
# If there was any output from the test, prefix it with " - " to
# separate it from the test result description.
test -n "${testOutput}" && testOutput=" - ${testOutput}"
# If stdout is not a terminal, don't use terminal format codes.
test -t 1 || resultFormatCodes=""
# Show the description of the test result.
test -n "${resultFormatCodes}" && command -v tput >/dev/null 2>&1 && echo "${resultFormatCodes}" | tr ';' '\n' | tput -S 2>/dev/null
printf "%s" "${testResultDescription}"
test -n "${resultFormatCodes}" && command -v tput >/dev/null 2>&1 && tput sgr0 2>/dev/null
# Show any output from the test, and start a new line.
printf "%s\n" "${testOutput}"
done
# Clean up.
rm -f "${workFile1}" "${workFile2}" "${workFile3}" "${workFile4}"
trap '' EXIT
# Exit with status 1 if any test failed outright, 0 otherwise.
exit ${overallExitStatus}
# EOF
tests/000-cat
+9 -2
View File
@@ -2,7 +2,14 @@
#
# Check that data can be just passed straight through.
VALUE=$(echo TESTING | $PROG 2>/dev/null) || exit 1
test "$VALUE" = "TESTING"
# Dummy assignment for "shellcheck".
testSubject="${testSubject:-false}"
inputString="TESTING"
outputString=$(printf "${inputString}" | "${testSubject}" 2>/dev/null) || { echo "unexpected failure code"; exit 1; }
test "${inputString}" = "${outputString}" && exit 0
echo "output did not match input"
exit 1
# EOF
tests/001-interval
+2 -2
View File
@@ -2,11 +2,11 @@
#
# Check that the update interval can be set.
sleep 1 | $PROG -f -i 0.1 >/dev/null 2>$TMP1
sleep 1 | "${testSubject}" -f -i 0.1 >/dev/null 2>"${workFile1}"
# There should be more than 6 lines of output.
#
NUM=$(tr '\r' '\n' < $TMP1 | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | wc -l | tr -d ' ')
test $NUM -gt 6
# EOF
tests/002-rate
+1 -1
View File
@@ -5,7 +5,7 @@
# Transfer 102 bytes at 100 bytes/sec. It should take at least 1 second.
#
START=$(date +%S)
dd if=/dev/zero bs=102 count=1 2>/dev/null | $PROG -L 100 2>/dev/null | cat >/dev/null
dd if=/dev/zero bs=102 count=1 2>/dev/null | "${testSubject}" -L 100 2>/dev/null | cat >/dev/null
END=$(date +%S)
test $START -ne $END
tests/003-progress
+2 -2
View File
@@ -3,11 +3,11 @@
# Check that the progress bar moves when data is coming in.
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| $PROG -f -p -i 0.1 -L 500 >/dev/null 2>$TMP1
| "${testSubject}" -f -p -i 0.1 -L 500 >/dev/null 2>"${workFile1}"
# There should be more than 2 different lines of output.
#
NUM=$(tr '\r' '\n' < $TMP1 | sort | uniq -u | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | sort | uniq -u | wc -l | tr -d ' ')
test $NUM -gt 2
# EOF
tests/004-timer
+2 -2
View File
@@ -4,11 +4,11 @@
# Transfer a zero amount of data, but take 3 seconds to do it.
#
(sleep 3 | $PROG -f -t >/dev/null) 2>&1 | tr '\r' '\n' > $TMP1
(sleep 3 | "${testSubject}" -f -t >/dev/null) 2>&1 | tr '\r' '\n' > "${workFile1}"
# Count the number of different timer values; it should be >1.
#
NUM=$(sort < $TMP1 | uniq -u | wc -l | tr -d ' ')
NUM=$(sort < "${workFile1}" | uniq -u | wc -l | tr -d ' ')
test $NUM -gt 1
# EOF
tests/005-eta
+2 -2
View File
@@ -3,11 +3,11 @@
# Check that the estimated time counter counts.
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| $PROG -f -e -s 100 -i 0.1 -L 25 >/dev/null 2>$TMP1
| "${testSubject}" -f -e -s 100 -i 0.1 -L 25 >/dev/null 2>"${workFile1}"
# Count the number of different ETA values there have been.
#
NUM=$(tr '\r' '\n' < $TMP1 | tr -d ' ' | sed '/^$/d' | sort | uniq | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | tr -d ' ' | sed '/^$/d' | sort | uniq | wc -l | tr -d ' ')
# 3 or less - not OK, since it should have taken 4 seconds.
#
tests/006-fineta
+2 -2
View File
@@ -3,11 +3,11 @@
# Check that the estimated time counter can show the end time of day.
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| $PROG -f -I -s 100 -i 0.1 -L 25 >/dev/null 2>$TMP1
| "${testSubject}" -f -I -s 100 -i 0.1 -L 25 >/dev/null 2>"${workFile1}"
# Count the number of different ETA values there have been.
#
NUM=$(tr '\r' '\n' < $TMP1 | tr -d ' ' | sed '/^$/d' | sort | uniq | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | tr -d ' ' | sed '/^$/d' | sort | uniq | wc -l | tr -d ' ')
# There should be at least 1 line of output.
#
tests/007-ratecount
+2 -2
View File
@@ -7,11 +7,11 @@
(dd if=/dev/zero bs=100 count=1 2>/dev/null;
sleep 2;
dd if=/dev/zero bs=100 count=1 2>/dev/null;
) | $PROG -f -i 0.5 -r >/dev/null 2>$TMP1
) | "${testSubject}" -f -i 0.5 -r >/dev/null 2>"${workFile1}"
# Count the number of different rates output.
#
NUM=$(tr '\r' '\n' < $TMP1 | sort | uniq -u | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | sort | uniq -u | wc -l | tr -d ' ')
# There should be more than 2 different rates counted (around 100 bytes/sec
# for the each block, 0 bytes/sec for the gap in the middle, and around 50
tests/008-bytes
+2 -2
View File
@@ -3,8 +3,8 @@
# Check that the byte counter counts.
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| LANG=C $PROG -f -b >/dev/null 2>$TMP1
NUM=$(tr '\r' '\n' < $TMP1 | tr -d ' ')
| LANG=C "${testSubject}" -f -b >/dev/null 2>"${workFile1}"
NUM=$(tr '\r' '\n' < "${workFile1}" | tr -d ' ')
test "$NUM" = "100B"
# EOF
tests/009-numeric
+4 -4
View File
@@ -6,13 +6,13 @@
# around 10 output lines.
#
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| $PROG -s 100 -n -i 0.1 -L 100 >/dev/null 2>$TMP1
| "${testSubject}" -s 100 -n -i 0.1 -L 100 >/dev/null 2>"${workFile1}"
# The number of output lines should be >8 and <13, and the final percentage
# should be 100.
#
test $(wc -l < $TMP1) -gt 8
test $(wc -l < $TMP1) -lt 13
test $(sed -n '$p' < $TMP1) -eq 100
test $(wc -l < "${workFile1}") -gt 8
test $(wc -l < "${workFile1}") -lt 13
test $(sed -n '$p' < "${workFile1}") -eq 100
# EOF
tests/010-quiet
+2 -2
View File
@@ -3,7 +3,7 @@
# Check that the -q option shuts everything up.
dd if=/dev/zero bs=1000 count=5 2>/dev/null \
| $PROG -f -q -i 0.1 -L 5000 >/dev/null 2>$TMP1
test ! -s $TMP1
| "${testSubject}" -f -q -i 0.1 -L 5000 >/dev/null 2>"${workFile1}"
test ! -s "${workFile1}"
# EOF
tests/011-pipe
+8 -8
View File
@@ -3,30 +3,30 @@
# Check that there is no SIGPIPE or dropped data on bigger data transfers.
# We nead GNU head. On some platforms it is named ghead instead of head.
HEAD=head
for p in $(echo $PATH | tr ':' '\n')
HEAD="head"
for checkPath in $(echo "${PATH}" | tr ':' '\n')
do
if test -x $p/ghead
if test -x "${checkPath}/ghead"
then
HEAD=$p/ghead
HEAD="${checkPath}/ghead"
break
fi
done
# Check that it really is GNU head, and skip the test if not.
if ! echo | $HEAD -c 10 >/dev/null 2>&1; then
if ! echo | "${HEAD}" -c 10 >/dev/null 2>&1; then
echo "GNU \`head' is required"
exit 2
fi
# Don't use dd. See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=324308
COUNT1=100000000
#COUNT2=`$PROG -B 100000 -q /dev/zero | $HEAD -c $COUNT1 | wc -c | tr -d ' '`
#COUNT2=`"${testSubject}" -B 100000 -q /dev/zero | $HEAD -c $COUNT1 | wc -c | tr -d ' '`
# Remove \n to fix the test on AIX
COUNT2=$($PROG -B 100000 -q /dev/zero | $HEAD -c $COUNT1 | tr -d '\n' | wc -c | tr -d ' ')
COUNT2=$("${testSubject}" -B 100000 -q /dev/zero | "${HEAD}" -c $COUNT1 | tr -d '\n' | wc -c | tr -d ' ')
#echo "[$COUNT1] [$COUNT2]"
test "x$COUNT1" = "x$COUNT2"
test "x${COUNT1}" = "x${COUNT2}"
# EOF
tests/012-cksum
+6 -6
View File
@@ -3,24 +3,24 @@
# Transfer a large chunk of data through pv and check data correctness
# afterwards.
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# exit on non-zero return codes
set -e
# generate some data
dd if=/dev/urandom of=$TMP1 bs=1024 count=10240 2>/dev/null
dd if=/dev/urandom of="${workFile1}" bs=1024 count=10240 2>/dev/null
CKSUM1=$(cksum $TMP1 | awk '{print $1}')
CKSUM1=$(cksum "${workFile1}" | awk '{print $1}')
# read through pv and test afterwards
$PROG -B 100000 -q $TMP1 > $TMP2
"${testSubject}" -B 100000 -q "${workFile1}" > "${workFile2}"
CKSUM2=$(cksum $TMP2 | awk '{print $1}')
CKSUM2=$(cksum "${workFile2}" | awk '{print $1}')
test "x$CKSUM1" = "x$CKSUM2"
# clean up
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# EOF
tests/013-averagerate
+2 -2
View File
@@ -10,11 +10,11 @@
sleep 1;
dd if=/dev/zero bs=110 count=1 2>/dev/null;
sleep 1;
) | $PROG -f -i 0.5 -a >/dev/null 2>$TMP1
) | "${testSubject}" -f -i 0.5 -a >/dev/null 2>"${workFile1}"
# Count the number of rates output that are below 80.
#
NUM=$(tr '\r' '\n' < $TMP1 | tr -dc '0-9.\n' | sed '/^$/d' | awk '$1<80{print}' | wc -l | tr -d ' ')
NUM=$(tr '\r' '\n' < "${workFile1}" | tr -dc '0-9.\n' | sed '/^$/d' | awk '$1<80{print}' | wc -l | tr -d ' ')
# Nearly all of the output rates should be above 80 since the average rate
# will always be around 100 bytes per second, except for pauses.
tests/014-1m_boundary_1
+3 -3
View File
@@ -12,14 +12,14 @@
sleep 1;
dd if=/dev/zero bs=1k count=500;
sleep 1;
) 2>/dev/null | ($PROG -btef -s 1500k >/dev/null) 2>$TMP1
) 2>/dev/null | ("${testSubject}" -btef -s 1500k >/dev/null) 2>"${workFile1}"
# Count how many different line lengths we've seen.
#
NUM=$(tr '\r' '\n' < $TMP1 | awk '{x=length($0);if(x>0)print length($0)}' | sort | uniq | wc -l)
NUM=$(tr '\r' '\n' < "${workFile1}" | awk '{x=length($0);if(x>0)print length($0)}' | sort | uniq | wc -l)
# There should only be one length (not counting 0).
#
test $NUM -eq 1 || { echo; tr '\r' '\n' < $TMP1; exit 1; }
test $NUM -eq 1 || { echo; tr '\r' '\n' < "${workFile1}"; exit 1; }
# EOF
tests/015-1m_boundary_2
+4 -4
View File
@@ -1,6 +1,6 @@
#!/bin/sh
#
# Same as test 13 (1mboundary) but for rate, not bytes transferred.
# Same as test (1m_boundary_1) but for rate, not bytes transferred.
# Transfer 1500kB of data in a bursty fashion.
#
@@ -12,14 +12,14 @@
sleep 1;
dd if=/dev/zero bs=1k count=500;
sleep 1;
) 2>/dev/null | ($PROG -rtef -s 1500k >/dev/null) 2>$TMP1
) 2>/dev/null | ("${testSubject}" -rtef -s 1500k >/dev/null) 2>"${workFile1}"
# Count how many different line lengths we've seen.
#
NUM=$(tr '\r' '\n' < $TMP1 | awk '{x=length($0);if(x>0)print length($0)}' | sort | uniq | wc -l)
NUM=$(tr '\r' '\n' < "${workFile1}" | awk '{x=length($0);if(x>0)print length($0)}' | sort | uniq | wc -l)
# There should only be one length (not counting 0).
#
test $NUM -eq 1 || { echo; tr '\r' '\n' < $TMP1; exit 1; }
test $NUM -eq 1 || { echo; tr '\r' '\n' < "${workFile1}"; exit 1; }
# EOF
tests/016-cksumpipe
+18 -18
View File
@@ -3,51 +3,51 @@
# Transfer a large chunk of data through pv using pipes, sending it in a
# bursty fashion, and check data correctness afterwards.
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# exit on non-zero return codes
set -e
# generate some data
dd if=/dev/urandom of=$TMP1 bs=1024 count=10240 2>/dev/null
dd if=/dev/urandom of="${workFile1}" bs=1024 count=10240 2>/dev/null
CKSUM1=$(cksum $TMP1 | awk '{print $1}')
CKSUM1=$(cksum "${workFile1}" | awk '{print $1}')
# read through pv and test afterwards
(
dd if=$TMP1 bs=1 count=9000
dd if="${workFile1}" bs=1 count=9000
sleep 1
dd if=$TMP1 bs=1 skip=9000 count=1240
dd if="${workFile1}" bs=1 skip=9000 count=1240
sleep 1
dd if=$TMP1 bs=1024 skip=10 count=1014
dd if="${workFile1}" bs=1024 skip=10 count=1014
sleep 1
dd if=$TMP1 bs=1024 skip=1024 count=1024
dd if="${workFile1}" bs=1024 skip=1024 count=1024
sleep 1
dd if=$TMP1 bs=1024 skip=2048
) 2>/dev/null | $PROG -q -L 2M | cat > $TMP2
dd if="${workFile1}" bs=1024 skip=2048
) 2>/dev/null | "${testSubject}" -q -L 2M | cat > "${workFile2}"
CKSUM2=$(cksum $TMP2 | awk '{print $1}')
CKSUM2=$(cksum "${workFile2}" | awk '{print $1}')
test "x$CKSUM1" = "x$CKSUM2"
# same again but with one less pipe
(
dd if=$TMP1 bs=1 count=9000
dd if="${workFile1}" bs=1 count=9000
sleep 1
dd if=$TMP1 bs=1 skip=9000 count=1240
dd if="${workFile1}" bs=1 skip=9000 count=1240
sleep 1
dd if=$TMP1 bs=1024 skip=10 count=1014
dd if="${workFile1}" bs=1024 skip=10 count=1014
sleep 1
dd if=$TMP1 bs=1024 skip=1024 count=1024
dd if="${workFile1}" bs=1024 skip=1024 count=1024
sleep 1
dd if=$TMP1 bs=1024 skip=2048
) 2>/dev/null | $PROG -q -L 2M > $TMP2
dd if="${workFile1}" bs=1024 skip=2048
) 2>/dev/null | "${testSubject}" -q -L 2M > "${workFile2}"
CKSUM2=$(cksum $TMP2 | awk '{print $1}')
CKSUM2=$(cksum "${workFile2}" | awk '{print $1}')
test "x$CKSUM1" = "x$CKSUM2"
# clean up
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# EOF
tests/017-numeric-timer
+5 -5
View File
@@ -6,15 +6,15 @@
# around 10 output lines.
#
dd if=/dev/zero bs=100 count=1 2>/dev/null \
| $PROG -s 100 -n -t -i 0.1 -L 100 >/dev/null 2>$TMP1
| "${testSubject}" -s 100 -n -t -i 0.1 -L 100 >/dev/null 2>"${workFile1}"
# The number of output lines should be >8 and <13, and the number of
# different elapsed times should be at least 7. The last percentage should
# be 100.
#
test $(wc -l < $TMP1) -gt 8
test $(wc -l < $TMP1) -lt 13
test $(tr , . < "$TMP1" | awk '{print int(10*$1)}' | sort -n | uniq | wc -l) -gt 7
test $(sed -n '$p' < $TMP1 | awk '{print $2}') -eq 100
test $(wc -l < "${workFile1}") -gt 8
test $(wc -l < "${workFile1}") -lt 13
test $(tr , . < ""${workFile1}"" | awk '{print int(10*$1)}' | sort -n | uniq | wc -l) -gt 7
test $(sed -n '$p' < "${workFile1}" | awk '{print $2}') -eq 100
# EOF
tests/018-numeric-bytes
+4 -4
View File
@@ -7,13 +7,13 @@
# around 10 output lines.
#
dd if=/dev/zero bs=500 count=1 2>/dev/null \
| $PROG -s 500 -n -b -i 0.1 -L 500 >/dev/null 2>$TMP1
| "${testSubject}" -s 500 -n -b -i 0.1 -L 500 >/dev/null 2>"${workFile1}"
# The number of output lines should be >8 and <13, and the final byte count
# should be 500.
#
test $(wc -l < $TMP1) -gt 8
test $(wc -l < $TMP1) -lt 13
test $(sed -n '$p' < $TMP1) -eq 500
test $(wc -l < "${workFile1}") -gt 8
test $(wc -l < "${workFile1}") -lt 13
test $(sed -n '$p' < "${workFile1}") -eq 500
# EOF
tests/019-remote-format
+9 -9
View File
@@ -3,30 +3,30 @@
# Try changing the format of a transfer remotely.
# Do nothing if IPC is not supported.
if ! $PROG -h | grep -Eq "^ -R,"; then
echo "SKIPPED" | tr "\n" ' '
exit 0
if ! "${testSubject}" -h 2>/dev/null | grep -Eq "^ -R,"; then
echo "IPC is not supported on this platform"
exit 2
fi
rm -f $TMP1 $TMP2 $TMP3 $TMP4 2>/dev/null
rm -f "${workFile1}" "${workFile2}" "${workFile3}" "${workFile4}" 2>/dev/null
# Exit on non-zero return codes.
set -e
# Generate an empty test file.
dd if=/dev/zero of=$TMP1 bs=1024 count=10240 2>/dev/null
dd if=/dev/zero of="${workFile1}" bs=1024 count=10240 2>/dev/null
(
sleep 1
$PROG -R $(cat $TMP4) -a
"${testSubject}" -R $(cat "${workFile4}") -a
sleep 2
$PROG -R $(cat $TMP4) -L 10M
"${testSubject}" -R $(cat "${workFile4}") -L 10M
) &
$PROG -L 2M -f -P $TMP4 $TMP1 > $TMP2 2>$TMP3
"${testSubject}" -L 2M -f -P "${workFile4}" "${workFile1}" > "${workFile2}" 2>"${workFile3}"
# Make sure there is more than one length of line (excluding blank lines).
line_lengths=$(tr '\r' '\n' < "$TMP3" | awk '{print length($0)}' | grep -Fvx 0 | sort -n | uniq | wc -l)
line_lengths=$(tr '\r' '\n' < "${workFile3}" | awk '{print length($0)}' | grep -Fvx 0 | sort -n | uniq | wc -l)
test $line_lengths -gt 1
# EOF
tests/020-remote-cksum
+17 -17
View File
@@ -4,51 +4,51 @@
# intact.
# Do nothing if IPC is not supported.
if ! $PROG -h | grep -Eq "^ -R,"; then
echo "SKIPPED" | tr "\n" ' '
exit 0
if ! "${testSubject}" -h 2>/dev/null | grep -Eq "^ -R,"; then
echo "IPC is not supported on this platform"
exit 2
fi
rm -f $TMP1 $TMP2 $TMP3 $TMP4 2>/dev/null
rm -f "${workFile1}" "${workFile2}" "${workFile3}" "${workFile4}" 2>/dev/null
# Exit on non-zero return codes.
set -e
# Generate some data.
dd if=/dev/urandom of=$TMP1 bs=1024 count=10240 2>/dev/null
dd if=/dev/urandom of="${workFile1}" bs=1024 count=10240 2>/dev/null
# Run a few remote control commands in the background.
#
echo FAIL > $TMP3
echo FAIL > "${workFile3}"
(
set +e
sleep 2
for x in 1 2 3; do
$PROG -R $(cat $TMP4) -apterb || exit 1
"${testSubject}" -R $(cat "${workFile4}") -apterb || exit 1
(usleep 200000 || sleep 1) 2>/dev/null
$PROG -R $(cat $TMP4) -p || exit 1
"${testSubject}" -R $(cat "${workFile4}") -p || exit 1
(usleep 200000 || sleep 1) 2>/dev/null
$PROG -R $(cat $TMP4) -N "test" || exit 1
"${testSubject}" -R $(cat "${workFile4}") -N "test" || exit 1
(usleep 200000 || sleep 1) 2>/dev/null
$PROG -R $(cat $TMP4) -F "%e" || exit 1
"${testSubject}" -R $(cat "${workFile4}") -F "%e" || exit 1
(usleep 200000 || sleep 1) 2>/dev/null
$PROG -R $(cat $TMP4) -N "." || exit 1
"${testSubject}" -R $(cat "${workFile4}") -N "." || exit 1
(usleep 200000 || sleep 1) 2>/dev/null
done
$PROG -R $(cat $TMP4) -L 10M
echo OK > $TMP3
"${testSubject}" -R $(cat "${workFile4}") -L 10M
echo OK > "${workFile3}"
) &
# Run our data transfer.
$PROG -L 100k -i 0.1 -f -P $TMP4 $TMP1 > $TMP2 2>/dev/null
"${testSubject}" -L 100k -i 0.1 -f -P "${workFile4}" "${workFile1}" > "${workFile2}" 2>/dev/null
# Check our remote control calls ran OK.
BGSTATUS=$(cat $TMP3)
BGSTATUS=$(cat "${workFile3}")
test "x$BGSTATUS" = "xOK"
# Check data integrity.
CKSUM1=$(cksum $TMP1 | awk '{print $1}')
CKSUM2=$(cksum $TMP2 | awk '{print $1}')
CKSUM1=$(cksum "${workFile1}" | awk '{print $1}')
CKSUM2=$(cksum "${workFile2}" | awk '{print $1}')
test "x$CKSUM1" = "x$CKSUM2"
# EOF
tests/021-stop-at-size
+9 -9
View File
@@ -2,27 +2,27 @@
#
# Make sure -S stops at the given size.
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# exit on non-zero return codes
set -e
# generate some data
dd if=/dev/urandom of=$TMP1 bs=1024 count=10 2>/dev/null
dd if=/dev/urandom of="${workFile1}" bs=1024 count=10 2>/dev/null
# read through pv and test afterwards
$PROG -S -s 5120 -q $TMP1 > $TMP2
"${testSubject}" -S -s 5120 -q "${workFile1}" > "${workFile2}"
CKSUM2=$(cksum $TMP2 | awk '{print $1}')
CKSUM2=$(cksum "${workFile2}" | awk '{print $1}')
# take the first 5120 bytes of TMP1 and cksum them
rm -f $TMP2
dd if=$TMP1 of=$TMP2 bs=1024 count=5 2>/dev/null
CKSUM1=$(cksum $TMP2 | awk '{print $1}')
# take the first 5120 bytes of workFile1 and cksum them
rm -f "${workFile2}"
dd if="${workFile1}" of="${workFile2}" bs=1024 count=5 2>/dev/null
CKSUM1=$(cksum "${workFile2}" | awk '{print $1}')
test "x$CKSUM1" = "x$CKSUM2"
# clean up
rm -f $TMP1 $TMP2 2>/dev/null
rm -f "${workFile1}" "${workFile2}" 2>/dev/null
# EOF
tests/022-large-file
+16 -16
View File
@@ -3,25 +3,25 @@
# Make sure that files larger than 2GB are supported.
# Check there is enough free space for this test.
TMP1DIR="${TMP1%/*}"
TMP1SPACEKB=$(df -kP "${TMP1DIR}" | sed -n '$p' | awk '{print $(NF-2)}')
test -n "${TMP1SPACEKB}" || TMP1SPACEKB=0
if ! test "${TMP1SPACEKB}" -gt 3300000 2>/dev/null; then
echo "need >3GB free on ${TMP1DIR}"
workFile1DIR="${workFile1%/*}"
workFile1SPACEKB=$(df -kP "${workFile1DIR}" | sed -n '$p' | awk '{print $(NF-2)}')
test -n "${workFile1SPACEKB}" || workFile1SPACEKB=0
if ! test "${workFile1SPACEKB}" -gt 3300000 2>/dev/null; then
echo "need >3GB free on ${workFile1DIR}"
exit 2
fi
# Generate a 3GB sparse file - we don't really need 3GB of free space unless
# sparse files are not supported.
echo -n > "${TMP1}"
if ! dd if="/dev/zero" of="${TMP1}" count=1 bs=1048576 seek=3072 2>/dev/null; then
echo -n > "${workFile1}"
if ! dd if="/dev/zero" of="${workFile1}" count=1 bs=1048576 seek=3072 2>/dev/null; then
echo "failed to create 3GB specimen file"
exit 2
fi
# NB the "stat" command is not portable - BSD stat(1) has a different syntax
# to GNU stat(1) - so we have to parse the output of ls(1).
FILESIZE=$(ls -nl "${TMP1}" 2>/dev/null | awk '{print $5}')
FILESIZE=$(ls -nl "${workFile1}" 2>/dev/null | awk '{print $5}')
test -n "${FILESIZE}" || FILESIZE=0
if ! test "${FILESIZE}" -gt 3000000; then
echo "failed to validate specimen file size"
@@ -29,9 +29,9 @@ if ! test "${FILESIZE}" -gt 3000000; then
fi
# Transfer the file, and count how many bytes came through.
TRANSFERRED=$("${PROG}" -n -b "${TMP1}" 2>"${TMP2}" | wc -c 2>/dev/null | tr -dc '0-9')
TRANSFERRED=$("${testSubject}" -n -b "${workFile1}" 2>"${workFile2}" | wc -c 2>/dev/null | tr -dc '0-9')
test -n "${TRANSFERRED}" || TRANSFERRED=0
COUNTED=$(sed -n '$p' "${TMP2}" | tr -dc '0-9')
COUNTED=$(sed -n '$p' "${workFile2}" | tr -dc '0-9')
test -n "${COUNTED}" || COUNTED=0
if ! test "${TRANSFERRED}" -eq "${FILESIZE}"; then
echo "transferred ${TRANSFERRED} of ${FILESIZE} bytes"
@@ -43,9 +43,9 @@ if ! test "${COUNTED}" -eq "${FILESIZE}"; then
fi
# Transfer the file from stdin, and count how many bytes came through.
TRANSFERRED=$("${PROG}" -n -b < "${TMP1}" 2>"${TMP2}" | wc -c 2>/dev/null | tr -dc '0-9')
TRANSFERRED=$("${testSubject}" -n -b < "${workFile1}" 2>"${workFile2}" | wc -c 2>/dev/null | tr -dc '0-9')
test -n "${TRANSFERRED}" || TRANSFERRED=0
COUNTED=$(sed -n '$p' "${TMP2}" | tr -dc '0-9')
COUNTED=$(sed -n '$p' "${workFile2}" | tr -dc '0-9')
test -n "${COUNTED}" || COUNTED=0
if ! test "${TRANSFERRED}" -eq "${FILESIZE}"; then
echo "stdin - transferred ${TRANSFERRED} of ${FILESIZE} bytes"
@@ -58,9 +58,9 @@ fi
# Use the file as a size value and transfer its size of bytes from dev/zero,
# and count how many bytes came through.
TRANSFERRED=$("${PROG}" -n -b -S -s "@${TMP1}" /dev/zero 2>"${TMP2}" | wc -c 2>/dev/null | tr -dc '0-9')
TRANSFERRED=$("${testSubject}" -n -b -S -s "@${workFile1}" /dev/zero 2>"${workFile2}" | wc -c 2>/dev/null | tr -dc '0-9')
test -n "${TRANSFERRED}" || TRANSFERRED=0
COUNTED=$(sed -n '$p' "${TMP2}" | tr -dc '0-9')
COUNTED=$(sed -n '$p' "${workFile2}" | tr -dc '0-9')
test -n "${COUNTED}" || COUNTED=0
if ! test "${TRANSFERRED}" -eq "${FILESIZE}"; then
echo "size read - transferred ${TRANSFERRED} of ${FILESIZE} bytes"
@@ -71,8 +71,8 @@ if ! test "${COUNTED}" -eq "${FILESIZE}"; then
exit 1
fi
echo -n > "${TMP1}"
echo -n > "${TMP2}"
echo -n > "${workFile1}"
echo -n > "${workFile2}"
exit 0