Adding upstream version 8.32.upstream/8.32upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 255 insertions, 0 deletions

diff --git a/tests/cp/same-file.sh b/tests/cp/same-file.sh
new file mode 100755
index 0000000..214f17b
--- /dev/null
+++ b/tests/cp/same-file.sh
@@ -0,0 +1,255 @@
+#!/bin/sh
+# Test some of cp's options and how cp handles situations in
+# which a naive implementation might overwrite the source file.
+
+# Copyright (C) 1998-2020 Free Software Foundation, Inc.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src
+print_ver_ cp
+
+# Unset CDPATH.  Otherwise, output from the 'cd dir' command
+# can make this test fail.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+VERSION_CONTROL=numbered; export VERSION_CONTROL
+
+# Determine whether a hard link to a symlink points to the symlink
+# itself or to its referent.  For example, the link from FreeBSD6.1
+# does dereference a symlink, but the one from Linux does not.
+ln -s no-such dangling-slink
+ln dangling-slink hard-link > /dev/null 2>&1 \
+  && hard_link_to_symlink_does_the_deref=no \
+  || hard_link_to_symlink_does_the_deref=yes
+rm -f no-such dangling-slink hard-link
+
+test $hard_link_to_symlink_does_the_deref = yes \
+    && remove_these_sed='/^0 -[bf]*l .*sl1 ->/d; /hlsl/d' \
+    || remove_these_sed='/^ELIDE NO TEST OUTPUT/d'
+
+exec 3>&1 1> actual
+
+# FIXME: This should be bigger: like more than 8k
+contents=XYZ
+
+for args in 'foo symlink' 'symlink foo' 'foo foo' 'sl1 sl2' \
+            'foo hardlink' 'hlsl sl2'; do
+  for options in '' -d -f -df --rem -b -bd -bf -bdf \
+                 -l -dl -fl -dfl -bl -bdl -bfl -bdfl -s -sf; do
+    case $args$options in
+      # These tests are not portable.
+      # They all involve making a hard link to a symbolic link.
+      # In the past, we've skipped the tests that are not portable,
+      # by doing "continue" here and eliminating the corresponding
+      # expected output lines below.  Don't do that anymore.
+      'symlink foo'-dfl)
+        continue;;
+      'symlink foo'-bdl)
+        continue;;
+      'symlink foo'-bdfl)
+        continue;;
+      'sl1 sl2'-dfl)
+        continue;;
+      'sl1 sl2'-bd*l)
+        continue;;
+      'sl1 sl2'-dl)
+        continue;;
+    esac
+
+    # cont'd  Instead, skip them only on systems for which link does
+    # dereference a symlink.  Detect and skip such tests here.
+    case $hard_link_to_symlink_does_the_deref:$args:$options in
+      'yes:sl1 sl2:-fl')
+        continue ;;
+      'yes:sl1 sl2:-bl')
+        continue ;;
+      'yes:sl1 sl2:-bfl')
+        continue ;;
+      yes:hlsl*)
+        continue ;;
+    esac
+
+    rm -rf dir
+    mkdir dir
+    cd dir
+    echo $contents > foo
+    case "$args" in *symlink*) ln -s foo symlink ;; esac
+    case "$args" in *hardlink*) ln foo hardlink ;; esac
+    case "$args" in *sl1*) ln -s foo sl1;; esac
+    case "$args" in *sl2*) ln -s foo sl2;; esac
+    case "$args" in *hlsl*) ln sl2 hlsl;; esac
+    (
+      (
+        # echo 1>&2 cp $options $args
+        cp $options $args 2>_err
+        echo $? $options
+
+        # Normalize the program name and diagnostics in the error output,
+        # and put brackets around the output.
+        if test -s _err; then
+          sed '
+            s/symbolic link/symlink/
+            s/^[^:]*:\([^:]*\).*/cp:\1/
+            1s/^/[/
+            $s/$/]/
+          ' _err
+        fi
+        # Strip off all but the file names.
+        ls=$(ls -gG --ignore=_err . \
+             | sed \
+                -e '/^total /d' \
+                -e 's/^[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *[^ ]*  *//')
+        echo "($ls)"
+        # Make sure the original is unchanged and that
+        # the destination is a copy.
+        for f in $args; do
+          if test -f $f; then
+            case "$(cat $f)" in
+              "$contents") ;;
+              *) echo cp FAILED;;
+            esac
+          else
+            echo symlink-loop
+          fi
+        done
+      ) | tr '\n' ' '
+      echo
+    ) | sed 's/  *$//'
+    cd ..
+  done
+  echo
+done
+
+cat <<\EOF | sed "$remove_these_sed" > expected
+1 [cp: 'foo' and 'symlink' are the same file] (foo symlink -> foo)
+1 -d [cp: 'foo' and 'symlink' are the same file] (foo symlink -> foo)
+1 -f [cp: 'foo' and 'symlink' are the same file] (foo symlink -> foo)
+1 -df [cp: 'foo' and 'symlink' are the same file] (foo symlink -> foo)
+0 --rem (foo symlink)
+0 -b (foo symlink symlink.~1~ -> foo)
+0 -bd (foo symlink symlink.~1~ -> foo)
+0 -bf (foo symlink symlink.~1~ -> foo)
+0 -bdf (foo symlink symlink.~1~ -> foo)
+1 -l [cp: cannot create hard link 'symlink' to 'foo'] (foo symlink -> foo)
+1 -dl [cp: cannot create hard link 'symlink' to 'foo'] (foo symlink -> foo)
+0 -fl (foo symlink)
+0 -dfl (foo symlink)
+0 -bl (foo symlink symlink.~1~ -> foo)
+0 -bdl (foo symlink symlink.~1~ -> foo)
+0 -bfl (foo symlink symlink.~1~ -> foo)
+0 -bdfl (foo symlink symlink.~1~ -> foo)
+1 -s [cp: cannot create symlink 'symlink' to 'foo'] (foo symlink -> foo)
+0 -sf (foo symlink -> foo)
+
+1 [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 -d [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 -f [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 -df [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 --rem [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 -b [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+0 -bd (foo -> foo foo.~1~ symlink -> foo) symlink-loop symlink-loop
+1 -bf [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+0 -bdf (foo -> foo foo.~1~ symlink -> foo) symlink-loop symlink-loop
+0 -l (foo symlink -> foo)
+0 -dl (foo symlink -> foo)
+0 -fl (foo symlink -> foo)
+0 -bl (foo symlink -> foo)
+0 -bfl (foo symlink -> foo)
+1 -s [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+1 -sf [cp: 'symlink' and 'foo' are the same file] (foo symlink -> foo)
+
+1 [cp: 'foo' and 'foo' are the same file] (foo)
+1 -d [cp: 'foo' and 'foo' are the same file] (foo)
+1 -f [cp: 'foo' and 'foo' are the same file] (foo)
+1 -df [cp: 'foo' and 'foo' are the same file] (foo)
+1 --rem [cp: 'foo' and 'foo' are the same file] (foo)
+1 -b [cp: 'foo' and 'foo' are the same file] (foo)
+1 -bd [cp: 'foo' and 'foo' are the same file] (foo)
+0 -bf (foo foo.~1~)
+0 -bdf (foo foo.~1~)
+0 -l (foo)
+0 -dl (foo)
+0 -fl (foo)
+0 -dfl (foo)
+0 -bl (foo)
+0 -bdl (foo)
+0 -bfl (foo foo.~1~)
+0 -bdfl (foo foo.~1~)
+1 -s [cp: 'foo' and 'foo' are the same file] (foo)
+1 -sf [cp: 'foo' and 'foo' are the same file] (foo)
+
+1 [cp: 'sl1' and 'sl2' are the same file] (foo sl1 -> foo sl2 -> foo)
+0 -d (foo sl1 -> foo sl2 -> foo)
+1 -f [cp: 'sl1' and 'sl2' are the same file] (foo sl1 -> foo sl2 -> foo)
+0 -df (foo sl1 -> foo sl2 -> foo)
+0 --rem (foo sl1 -> foo sl2)
+0 -b (foo sl1 -> foo sl2 sl2.~1~ -> foo)
+0 -bd (foo sl1 -> foo sl2 -> foo sl2.~1~ -> foo)
+0 -bf (foo sl1 -> foo sl2 sl2.~1~ -> foo)
+0 -bdf (foo sl1 -> foo sl2 -> foo sl2.~1~ -> foo)
+1 -l [cp: cannot create hard link 'sl2' to 'sl1'] (foo sl1 -> foo sl2 -> foo)
+0 -fl (foo sl1 -> foo sl2)
+0 -bl (foo sl1 -> foo sl2 sl2.~1~ -> foo)
+0 -bfl (foo sl1 -> foo sl2 sl2.~1~ -> foo)
+1 -s [cp: cannot create symlink 'sl2' to 'sl1'] (foo sl1 -> foo sl2 -> foo)
+0 -sf (foo sl1 -> foo sl2 -> sl1)
+
+1 [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+1 -d [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+1 -f [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+1 -df [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+0 --rem (foo hardlink)
+0 -b (foo hardlink hardlink.~1~)
+0 -bd (foo hardlink hardlink.~1~)
+0 -bf (foo hardlink hardlink.~1~)
+0 -bdf (foo hardlink hardlink.~1~)
+0 -l (foo hardlink)
+0 -dl (foo hardlink)
+0 -fl (foo hardlink)
+0 -dfl (foo hardlink)
+0 -bl (foo hardlink)
+0 -bdl (foo hardlink)
+0 -bfl (foo hardlink)
+0 -bdfl (foo hardlink)
+1 -s [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+1 -sf [cp: 'foo' and 'hardlink' are the same file] (foo hardlink)
+
+1 [cp: 'hlsl' and 'sl2' are the same file] (foo hlsl -> foo sl2 -> foo)
+0 -d (foo hlsl -> foo sl2 -> foo)
+1 -f [cp: 'hlsl' and 'sl2' are the same file] (foo hlsl -> foo sl2 -> foo)
+0 -df (foo hlsl -> foo sl2 -> foo)
+0 --rem (foo hlsl -> foo sl2)
+0 -b (foo hlsl -> foo sl2 sl2.~1~ -> foo)
+0 -bd (foo hlsl -> foo sl2 -> foo sl2.~1~ -> foo)
+0 -bf (foo hlsl -> foo sl2 sl2.~1~ -> foo)
+0 -bdf (foo hlsl -> foo sl2 -> foo sl2.~1~ -> foo)
+1 -l [cp: cannot create hard link 'sl2' to 'hlsl'] (foo hlsl -> foo sl2 -> foo)
+0 -dl (foo hlsl -> foo sl2 -> foo)
+0 -fl (foo hlsl -> foo sl2)
+0 -dfl (foo hlsl -> foo sl2 -> foo)
+0 -bl (foo hlsl -> foo sl2 sl2.~1~ -> foo)
+0 -bdl (foo hlsl -> foo sl2 -> foo)
+0 -bfl (foo hlsl -> foo sl2 sl2.~1~ -> foo)
+0 -bdfl (foo hlsl -> foo sl2 -> foo)
+1 -s [cp: cannot create symlink 'sl2' to 'hlsl'] (foo hlsl -> foo sl2 -> foo)
+0 -sf (foo hlsl -> foo sl2 -> hlsl)
+
+EOF
+
+exec 1>&3 3>&-
+
+compare expected actual 1>&2 || fail=1
+
+Exit $fail