mirror of
https://github.com/coreutils/coreutils.git
synced 2024-12-14 20:35:13 +08:00
209 lines
6.8 KiB
Bash
Executable File
209 lines
6.8 KiB
Bash
Executable File
#!/bin/sh
|
|
# make sure cp and mv can handle many combinations of local and
|
|
# other-partition regular/symlink'd files.
|
|
|
|
if test "$VERBOSE" = yes; then
|
|
set -x
|
|
mv --version
|
|
cp --version
|
|
fi
|
|
|
|
pwd=`pwd`
|
|
tmp=part-sl.$$
|
|
trap 'status=$?; cd $pwd; exec 1>&2; rm -rf $tmp $other_partition_tmpdir && exit $status' 0
|
|
trap '(exit $?); exit' 1 2 13 15
|
|
|
|
pwd_tmp=$pwd/$tmp
|
|
|
|
. $srcdir/setup
|
|
. $srcdir/../envvar-check
|
|
# Make sure the programs use C-locale formats/translations.
|
|
. $srcdir/../lang-default
|
|
|
|
if test -z "$other_partition_tmpdir"; then
|
|
(exit 77); exit
|
|
fi
|
|
|
|
framework_failure=0
|
|
mkdir $tmp || framework_failure=1
|
|
cd $tmp || framework_failure=1
|
|
|
|
if test $framework_failure = 1; then
|
|
echo 'failure in testing framework'
|
|
exit 1
|
|
fi
|
|
|
|
fail=0
|
|
|
|
# Four cases:
|
|
# local regular file w/symlink on another partition
|
|
# (loc_reg, rem_sl)
|
|
# (rem_sl, loc_reg)
|
|
# local symlink to regular file on another partition
|
|
# (loc_sl, rem_reg)
|
|
# (rem_reg, loc_sl)
|
|
|
|
# Exercise those four cases for each of
|
|
# cp and mv, with lots of combinations of options.
|
|
|
|
actual=actual-$$
|
|
expected=expected-$$
|
|
|
|
exec 1> $actual
|
|
|
|
# FIXME: This should be bigger: like more than 8k
|
|
contents=XYZ
|
|
|
|
loc_reg=loc_reg
|
|
loc_sl=loc_sl
|
|
rem_reg=$other_partition_tmpdir/rem_reg
|
|
rem_sl=$other_partition_tmpdir/rem_sl
|
|
|
|
for copy in cp mv; do
|
|
for args in \
|
|
'loc_reg rem_sl' \
|
|
'rem_sl loc_reg' \
|
|
'loc_sl rem_reg' \
|
|
'rem_reg loc_sl' \
|
|
; do
|
|
for options in '' --rem '--rem -d' '--rem -b' -b -bd -d; do
|
|
case "$options" in *d*|*--rem*) test $copy = mv && continue;; esac
|
|
rm -rf dir || fail=1
|
|
rm -f $other_partition_tmpdir/* || fail=1
|
|
mkdir dir || fail=1
|
|
cd dir || fail=1
|
|
case "$args" in *loc_reg*) reg_abs="`pwd`/$loc_reg" ;; esac
|
|
case "$args" in *rem_reg*) reg_abs=$rem_reg ;; esac
|
|
case "$args" in *loc_sl*) slink=$loc_sl ;; esac
|
|
case "$args" in *rem_sl*) slink=$rem_sl ;; esac
|
|
|
|
echo $contents > $reg_abs || fail=1
|
|
ln -nsf $reg_abs $slink || fail=1
|
|
actual_args=`echo $args|sed 's,^,$,;s/ / $/'`
|
|
actual_args=`eval echo $actual_args`
|
|
|
|
(
|
|
(
|
|
# echo 1>&2 cp $options $args
|
|
$copy $options $actual_args 2>.err
|
|
copy_status=$?
|
|
echo $copy_status $copy $options $args
|
|
|
|
# Normalize the program name in the error output,
|
|
# remove any site-dependent part of other-partition file name,
|
|
# and put brackets around the output.
|
|
test -s .err && {
|
|
echo '[' | tr -d '\012'
|
|
sed 's/^[^:][^:]*\(..\):/\1:/;s,'$other_partition_tmpdir/,, .err
|
|
echo ']' | tr -d '\012'
|
|
}
|
|
# Strip off all but the file names.
|
|
# Remove any site-dependent part of each file name.
|
|
ls="`ls -lG --ignore=.err . \
|
|
| sed \
|
|
-e '/^total /d' \
|
|
-e s,$other_partition_tmpdir/,, \
|
|
-e s,$pwd_tmp/,, \
|
|
-e 's/^...............................................//'`"
|
|
ls2="`cd $other_partition_tmpdir && ls -lG --ignore=.err . \
|
|
| sed \
|
|
-e '/^total /d' \
|
|
-e s,$other_partition_tmpdir/,, \
|
|
-e s,$pwd_tmp/,, \
|
|
-e 's/^...............................................//'`"
|
|
echo "($ls) ($ls2)"
|
|
|
|
# If the command failed, then it must not have changed the files.
|
|
if test $copy_status != 0; then
|
|
for f in $actual_args; do
|
|
test -f $f ||
|
|
{ echo "$copy FAILED but removed $f"; continue; }
|
|
case "`cat $f`" in
|
|
"$contents") ;;
|
|
*) echo "$copy FAILED but modified $f";;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
if test $copy = cp; then
|
|
# Make sure the original is unchanged and that
|
|
# the destination is a copy.
|
|
for f in $actual_args; do
|
|
if test -f $f; then
|
|
if test $copy_status != 0; then
|
|
test
|
|
fi
|
|
case "`cat $f`" in
|
|
"$contents") ;;
|
|
*) echo $copy FAILED;;
|
|
esac
|
|
else
|
|
echo symlink-loop
|
|
fi
|
|
done
|
|
fi
|
|
) | tr '\012' ' '
|
|
echo
|
|
) | sed 's/ *$//'
|
|
cd ..
|
|
done
|
|
echo
|
|
done
|
|
done
|
|
|
|
test $fail = 1 &&
|
|
{ (exit 1); exit; }
|
|
|
|
cat <<\EOF > $expected
|
|
1 cp loc_reg rem_sl [cp: `loc_reg' and `rem_sl' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
0 cp --rem loc_reg rem_sl (loc_reg) (rem_sl)
|
|
0 cp --rem -d loc_reg rem_sl (loc_reg) (rem_sl)
|
|
0 cp --rem -b loc_reg rem_sl (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)
|
|
0 cp -b loc_reg rem_sl (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)
|
|
0 cp -bd loc_reg rem_sl (loc_reg) (rem_sl rem_sl~ -> dir/loc_reg)
|
|
1 cp -d loc_reg rem_sl [cp: `loc_reg' and `rem_sl' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
|
|
1 cp rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
1 cp --rem rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
1 cp --rem -d rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
1 cp --rem -b rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
1 cp -b rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
0 cp -bd rem_sl loc_reg (loc_reg -> dir/loc_reg loc_reg~) (rem_sl -> dir/loc_reg) symlink-loop symlink-loop
|
|
1 cp -d rem_sl loc_reg [cp: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
|
|
1 cp loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
1 cp --rem loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
1 cp --rem -d loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
1 cp --rem -b loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
1 cp -b loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
0 cp -bd loc_sl rem_reg (loc_sl -> rem_reg) (rem_reg -> rem_reg rem_reg~) symlink-loop symlink-loop
|
|
1 cp -d loc_sl rem_reg [cp: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
|
|
1 cp rem_reg loc_sl [cp: `rem_reg' and `loc_sl' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
0 cp --rem rem_reg loc_sl (loc_sl) (rem_reg)
|
|
0 cp --rem -d rem_reg loc_sl (loc_sl) (rem_reg)
|
|
0 cp --rem -b rem_reg loc_sl (loc_sl loc_sl~ -> rem_reg) (rem_reg)
|
|
0 cp -b rem_reg loc_sl (loc_sl loc_sl~ -> rem_reg) (rem_reg)
|
|
0 cp -bd rem_reg loc_sl (loc_sl loc_sl~ -> rem_reg) (rem_reg)
|
|
1 cp -d rem_reg loc_sl [cp: `rem_reg' and `loc_sl' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
|
|
0 mv loc_reg rem_sl () (rem_sl)
|
|
0 mv -b loc_reg rem_sl () (rem_sl rem_sl~ -> dir/loc_reg)
|
|
|
|
1 mv rem_sl loc_reg [mv: `rem_sl' and `loc_reg' are the same file ](loc_reg) (rem_sl -> dir/loc_reg)
|
|
0 mv -b rem_sl loc_reg (loc_reg -> dir/loc_reg loc_reg~) ()
|
|
|
|
1 mv loc_sl rem_reg [mv: `loc_sl' and `rem_reg' are the same file ](loc_sl -> rem_reg) (rem_reg)
|
|
0 mv -b loc_sl rem_reg () (rem_reg -> rem_reg rem_reg~)
|
|
|
|
0 mv rem_reg loc_sl (loc_sl) ()
|
|
0 mv -b rem_reg loc_sl (loc_sl loc_sl~ -> rem_reg) ()
|
|
|
|
EOF
|
|
|
|
# Some folks may don't have diff.
|
|
cmp $expected $actual \
|
|
|| { diff -c $expected $actual 1>&2; fail=1; }
|
|
|
|
(exit $fail); exit
|