Adding upstream version 3.2.7.upstream/3.2.7

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

44 files changed, 3166 insertions, 0 deletions

diff --git a/testsuite/00-hello.test b/testsuite/00-hello.test
new file mode 100644
index 0000000..ebd0683
--- /dev/null
+++ b/testsuite/00-hello.test
@@ -0,0 +1,61 @@
+#!/bin/sh
+
+# Test some foundational things.
+
+. "$suitedir/rsync.fns"
+
+RSYNC_RSH="$scratchdir/src/support/lsh.sh"
+export RSYNC_RSH
+
+echo $0 running
+
+$RSYNC --version || test_fail '--version output failed'
+
+$RSYNC --info=help || test_fail '--info=help output failed'
+
+$RSYNC --debug=help || test_fail '--debug=help output failed'
+
+weird_name="A weird)name"
+
+mkdir "$fromdir"
+mkdir "$fromdir/$weird_name"
+
+append_line() {
+    echo "$1"
+    echo "$1" >>"$fromdir/$weird_name/file"
+}
+
+append_line test1
+checkit "$RSYNC -ai '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+copy_weird() {
+    checkit "$RSYNC $1 --rsync-path='$RSYNC' '$2$fromdir/$weird_name/' '$3$todir/$weird_name'" "$fromdir" "$todir"
+}
+
+append_line test2
+copy_weird '-ai' 'lh:' ''
+
+append_line test3
+copy_weird '-ai' '' 'lh:'
+
+append_line test4
+copy_weird '-ais' 'lh:' ''
+
+append_line test5
+copy_weird '-ais' '' 'lh:'
+
+echo test6
+
+touch "$fromdir/one" "$fromdir/two"
+(cd "$fromdir" && $RSYNC -ai --old-args --rsync-path="$RSYNC" lh:'one two' "$todir/")
+if [ ! -f "$todir/one" ] || [ ! -f "$todir/two" ]; then
+    test_fail "old-args copy of 'one two' failed"
+fi
+
+echo test7
+
+rm "$todir/one" "$todir/two"
+(cd "$fromdir" && RSYNC_OLD_ARGS=1 $RSYNC -ai --rsync-path="$RSYNC" lh:'one two' "$todir/")
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/README.testsuite b/testsuite/README.testsuite
new file mode 100644
index 0000000..782cb1c
--- /dev/null
+++ b/testsuite/README.testsuite
@@ -0,0 +1,28 @@
+automatic testsuite for rsync			-*- text -*-
+
+We're trying to develop some more substantial tests to prevent rsync
+regressions.  Ideally, all code changes or bug reports would come with
+an appropriate test suite.
+
+You can run these tests by typing "make check" in the build directory.
+The tests will run using the rsync binary in the build directory, so
+you do not need to do "make install" first.  Indeed, you probably
+should not install rsync before running the tests.
+
+If you instead type "make installcheck" then the suite will test the
+rsync binary from its installed location (e.g. /usr/local/bin/rsync).
+You can use this to test a distribution build, or perhaps to run a new
+test suite against an old version of rsync.  Note that in accordance
+with the GNU Standards, installcheck does not look for rsync on the
+path.
+
+If the tests pass, you should see a report to that effect.  Some tests
+require being root or some other precondition, and so will normally not
+be checked -- look at the test scripts for more information.
+
+If the tests fail, you will see rather more output.  The scratch
+directory will remain in the build directory.  It would be useful if
+you could include the log messages when reporting a failure.
+
+These tests also run automatically on the build farm, and you can see
+the results on http://build.samba.org/.
diff --git a/testsuite/acls-default.test b/testsuite/acls-default.test
new file mode 100644
index 0000000..d8fba7f
--- /dev/null
+++ b/testsuite/acls-default.test
@@ -0,0 +1,66 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync obeys default ACLs. -- Matt McCutchen
+
+. $suitedir/rsync.fns
+
+$RSYNC -VV | grep '"ACLs": true' >/dev/null || test_skipped "Rsync is configured without ACL support"
+
+case "$setfacl_nodef" in
+true) test_skipped "I don't know how to use your setfacl command" ;;
+*-k*) opts='-dm u::7,g::5,o:5' ;;
+*) opts='-m d:u::7,d:g::5,d:o:5' ;;
+esac
+setfacl $opts "$scratchdir" || test_skipped "Your filesystem has ACLs disabled"
+
+# Call as: testit <dirname> <default-acl> <file-expected> <program-expected>
+testit() {
+    todir="$scratchdir/$1"
+    mkdir "$todir"
+    $setfacl_nodef "$todir"
+    if [ -n "$2" ]; then
+	case "$setfacl_nodef" in
+	*-k*) opts="-dm $2" ;;
+	*) opts="-m `echo $2 | sed 's/\([ugom]:\)/d:\1/g'`"
+	esac
+	setfacl $opts "$todir"
+    fi
+    # Make sure we obey ACLs when creating a directory to hold multiple transferred files,
+    # even though the directory itself is outside the transfer
+    $RSYNC -rvv "$scratchdir/dir" "$scratchdir/file" "$scratchdir/program" "$todir/to/"
+    check_perms "$todir/to" $4 "Target $1"
+    check_perms "$todir/to/dir" $4 "Target $1"
+    check_perms "$todir/to/file" $3 "Target $1"
+    check_perms "$todir/to/program" $4 "Target $1"
+    # Make sure get_local_name doesn't mess us up when transferring only one file
+    $RSYNC -rvv "$scratchdir/file" "$todir/to/anotherfile"
+    check_perms "$todir/to/anotherfile" $3 "Target $1"
+    # Make sure we obey default ACLs when not transferring a regular file
+    $RSYNC -rvv "$scratchdir/dir/" "$todir/to/anotherdir/"
+    check_perms "$todir/to/anotherdir" $4 "Target $1"
+}
+
+mkdir "$scratchdir/dir"
+echo "File!" >"$scratchdir/file"
+echo "#!/bin/sh" >"$scratchdir/program"
+chmod 777 "$scratchdir/dir"
+chmod 666 "$scratchdir/file"
+chmod 777 "$scratchdir/program"
+
+# Test some target directories
+umask 0077
+testit da777 u::7,g::7,o:7 rw-rw-rw- rwxrwxrwx
+testit da775 u::7,g::7,o:5 rw-rw-r-- rwxrwxr-x
+testit da750 u::7,g::5,o:0 rw-r----- rwxr-x---
+testit da750mask u::7,u:0:7,g::7,m:5,o:0 rw-r----- rwxr-x---
+testit noda1 '' rw------- rwx------
+umask 0000
+testit noda2 '' rw-rw-rw- rwxrwxrwx
+umask 0022
+testit noda3 '' rw-r--r-- rwxr-xr-x
+
+# Hooray
+exit 0
diff --git a/testsuite/acls.test b/testsuite/acls.test
new file mode 100644
index 0000000..693da66
--- /dev/null
+++ b/testsuite/acls.test
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync handles basic ACL preservation.
+
+. $suitedir/rsync.fns
+
+$RSYNC -VV | grep '"ACLs": true' >/dev/null || test_skipped "Rsync is configured without ACL support"
+
+makepath "$fromdir/foo"
+echo something >"$fromdir/file1"
+echo else >"$fromdir/file2"
+
+files='foo file1 file2'
+
+case "$setfacl_nodef" in
+true)
+    if ! chmod --help 2>&1 | grep -F +a >/dev/null; then
+        test_skipped "I don't know how to use setfacl or chmod for ACLs"
+    fi
+    chmod +a "root allow read,write,execute" "$fromdir/foo" || test_skipped "Your filesystem has ACLs disabled"
+    chmod +a "root allow read,execute" "$fromdir/file1"
+    chmod +a "admin allow read" "$fromdir/file1"
+    chmod +a "daemon allow read,write" "$fromdir/file1"
+    chmod +a "root allow read,execute" "$fromdir/file2"
+
+    see_acls() {
+        ls -le "${@}"
+    }
+    ;;
+*)
+    setfacl -m u:0:7 "$fromdir/foo" || test_skipped "Your filesystem has ACLs disabled"
+    setfacl -m g:1:5 "$fromdir/foo"
+    setfacl -m g:2:1 "$fromdir/foo"
+    setfacl -m g:0:7 "$fromdir/foo"
+    setfacl -m u:2:1 "$fromdir/foo"
+    setfacl -m u:1:5 "$fromdir/foo"
+
+    setfacl -m u:0:5 "$fromdir/file1"
+    setfacl -m g:0:4 "$fromdir/file1"
+    setfacl -m u:1:6 "$fromdir/file1"
+
+    setfacl -m u:0:5 "$fromdir/file2"
+
+    see_acls() {
+        getfacl "${@}"
+    }
+    ;;
+esac
+
+cd "$fromdir"
+$RSYNC -avvA $files "$todir/"
+
+see_acls $files >"$scratchdir/acls.txt"
+
+cd "$todir"
+see_acls $files | diff $diffopt "$scratchdir/acls.txt" -
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/alt-dest.test b/testsuite/alt-dest.test
new file mode 100644
index 0000000..d2fb5a1
--- /dev/null
+++ b/testsuite/alt-dest.test
@@ -0,0 +1,68 @@
+#!/bin/sh
+
+# Copyright (C) 2004-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of --compare-dest and similar options.
+
+. "$suitedir/rsync.fns"
+
+alt1dir="$tmpdir/alt1"
+alt2dir="$tmpdir/alt2"
+alt3dir="$tmpdir/alt3"
+
+SSH="$scratchdir/src/support/lsh.sh"
+
+# Build some files/dirs/links to copy
+
+hands_setup
+
+# Setup the alt and chk dirs
+$RSYNC -av --include=text --include='*/' --exclude='*' "$fromdir/" "$alt1dir/"
+$RSYNC -av --include=etc-ltr-list --include='*/' --exclude='*' "$fromdir/" "$alt2dir/"
+
+# Create a side dir where there is a candidate destfile of the same name as a sourcefile
+echo "This is a test file" >"$fromdir/likely"
+
+mkdir "$alt3dir"
+echo "This is a test file" >"$alt3dir/likely"
+
+sleep 1
+touch "$fromdir/dir/text" "$fromdir/likely"
+
+$RSYNC -av --exclude=/text --exclude=etc-ltr-list "$fromdir/" "$chkdir/"
+
+# Let's do it!
+checkit "$RSYNC -avv --no-whole-file \
+    --compare-dest='$alt1dir' --compare-dest='$alt2dir' \
+    '$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+rm -rf "$todir"
+checkit "$RSYNC -avv --no-whole-file \
+    --copy-dest='$alt1dir' --copy-dest='$alt2dir' \
+    '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+# Test that copy_file() works correctly with tmpfiles
+for maybe_inplace in '' --inplace; do
+    rm -rf "$todir"
+    checkit "$RSYNC -av $maybe_inplace --copy-dest='$alt3dir' \
+	'$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+    for srchost in '' 'localhost:'; do
+	if [ -z "$srchost" ]; then
+	    desthost='localhost:'
+	else
+	    desthost=''
+	fi
+
+	rm -rf "$todir"
+	checkit "$RSYNC -ave '$SSH' --rsync-path='$RSYNC' $maybe_inplace \
+	    --copy-dest='$alt3dir' '$srchost$fromdir/' '$desthost$todir/'" \
+	    "$fromdir" "$todir"
+    done
+done
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/atimes.test b/testsuite/atimes.test
new file mode 100644
index 0000000..4d46eb0
--- /dev/null
+++ b/testsuite/atimes.test
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+# Test rsync copying atimes
+
+. "$suitedir/rsync.fns"
+
+$RSYNC -VV | grep '"atimes": true' >/dev/null || test_skipped "Rsync is configured without atimes support"
+
+mkdir "$fromdir"
+
+touch "$fromdir/foo"
+touch -a -t 200102031717.42 "$fromdir/foo"
+
+TLS_ARGS=--atimes
+
+checkit "$RSYNC -rtUgvvv \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/backup.test b/testsuite/backup.test
new file mode 100644
index 0000000..4de3867
--- /dev/null
+++ b/testsuite/backup.test
@@ -0,0 +1,63 @@
+#!/bin/sh
+
+# Copyright (C) 2004-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that the --backup option works right.
+
+. "$suitedir/rsync.fns"
+
+bakdir="$tmpdir/bak"
+
+makepath "$fromdir/deep" "$bakdir/dname"
+name1="$fromdir/deep/name1"
+name2="$fromdir/deep/name2"
+
+cat "$srcdir"/[gr]*.[ch] > "$name1"
+cat "$srcdir"/[et]*.[ch] > "$name2"
+
+checkit "$RSYNC -ai --info=backup '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+checkit "$RSYNC -ai --info=backup '$fromdir/' '$chkdir/'" "$fromdir" "$chkdir"
+cat "$srcdir"/[fgpr]*.[ch] > "$name1"
+cat "$srcdir"/[etw]*.[ch] > "$name2"
+
+checktee "$RSYNC -ai --info=backup --no-whole-file --backup '$fromdir/' '$todir/'"
+for fn in deep/name1 deep/name2; do
+    grep "backed up $fn to $fn~" "$outfile" >/dev/null || test_fail "no backup message output for $fn"
+    diff $diffopt "$fromdir/$fn" "$todir/$fn" || test_fail "copy of $fn failed"
+    diff $diffopt "$chkdir/$fn" "$todir/$fn~" || test_fail "backup of $fn to $fn~ failed"
+    mv "$todir/$fn~" "$todir/$fn"
+done
+
+echo deleted-file >"$todir/dname"
+cp_touch "$todir/dname" "$chkdir"
+
+checkit "$RSYNC -ai --info=backup --no-whole-file --delete-delay \
+    --backup --backup-dir='$bakdir' '$fromdir/' '$todir/'" "$fromdir" "$todir" \
+    | tee "$outfile"
+
+for fn in deep/name1 deep/name2; do
+    grep "backed up $fn to .*/$fn$" "$outfile" >/dev/null || test_fail "no backup message output for $fn"
+done
+diff -r $diffopt "$chkdir" "$bakdir" || test_fail "backup dir contents are bogus"
+rm "$bakdir/dname"
+
+checkit "$RSYNC -ai --info=backup --del '$fromdir/' '$chkdir/'" "$fromdir" "$chkdir"
+cat "$srcdir"/[efgr]*.[ch] > "$name1"
+cat "$srcdir"/[ew]*.[ch] > "$name2"
+
+checkit "$RSYNC -ai --info=backup --inplace --no-whole-file --backup --backup-dir='$bakdir' '$fromdir/' '$todir/'" "$fromdir" "$todir" \
+    | tee "$outfile"
+
+for fn in deep/name1 deep/name2; do
+    grep "backed up $fn to .*/$fn$" "$outfile" >/dev/null || test_fail "no backup message output for $fn"
+done
+diff -r $diffopt "$chkdir" "$bakdir" || test_fail "backup dir contents are bogus"
+
+checkit "$RSYNC -ai --info=backup --inplace --no-whole-file '$fromdir/' '$bakdir/'" "$fromdir" "$bakdir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/batch-mode.test b/testsuite/batch-mode.test
new file mode 100644
index 0000000..cf4e94d
--- /dev/null
+++ b/testsuite/batch-mode.test
@@ -0,0 +1,51 @@
+#!/bin/sh
+
+# Copyright (C) 2004 by Chris Shoemaker <c.shoemaker@cox.net>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync's --write-batch and --read-batch options
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+cd "$tmpdir"
+
+# Build chkdir for the daemon tests using a normal rsync and an --exclude.
+$RSYNC -av --exclude=foobar.baz "$fromdir/" "$chkdir/"
+
+$RSYNC -av --only-write-batch=BATCH --exclude=foobar.baz "$fromdir/" "$todir/missing/"
+test -d "$todir/missing" && test_fail "--only-write-batch should not have created destination dir"
+
+runtest "--read-batch (only)" 'checkit "$RSYNC -av --read-batch=BATCH \"$todir\"" "$chkdir" "$todir"'
+
+rm -rf "$todir" BATCH*
+runtest "local --write-batch" 'checkit "$RSYNC -av --write-batch=BATCH \"$fromdir/\" \"$todir\"" "$fromdir" "$todir"'
+
+rm -rf "$todir"
+runtest "--read-batch" 'checkit "$RSYNC -av --read-batch=BATCH \"$todir\"" "$fromdir" "$todir"'
+
+build_rsyncd_conf
+
+RSYNC_CONNECT_PROG="$RSYNC --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+rm -rf "$todir"
+runtest "daemon sender --write-batch" 'checkit "$RSYNC -av --write-batch=BATCH rsync://localhost/test-from/ \"$todir\"" "$chkdir" "$todir"'
+
+rm -rf "$todir"
+runtest "--read-batch from daemon" 'checkit "$RSYNC -av --read-batch=BATCH \"$todir\"" "$chkdir" "$todir"'
+
+rm -rf "$todir"
+runtest "BATCH.sh use of --read-batch" 'checkit "./BATCH.sh" "$chkdir" "$todir"'
+
+runtest "do-nothing re-run of batch" 'checkit "./BATCH.sh" "$chkdir" "$todir"'
+
+rm -rf "$todir"
+mkdir "$todir" || test_fail "failed to restore empty destination directory"
+runtest "daemon recv --write-batch" 'checkit "\"$ignore23\" $RSYNC -av --write-batch=BATCH \"$fromdir/\" rsync://localhost/test-to" "$chkdir" "$todir"'
+
+# The script would have aborted on error, so getting here means we pass.
+exit 0
diff --git a/testsuite/chgrp.test b/testsuite/chgrp.test
new file mode 100644
index 0000000..467d402
--- /dev/null
+++ b/testsuite/chgrp.test
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync with -gr will preserve groups when the user running
+# the test is a member of them.  Hopefully they're in at least one
+# test.
+
+. "$suitedir/rsync.fns"
+
+# Build some hardlinks
+
+mygrps="`rsync_getgroups`" || test_fail "Can't get groups"
+mkdir "$fromdir"
+
+for g in $mygrps; do
+    name="$fromdir/foo-$g"
+    date > "$name"
+    chgrp "$g" "$name" || test_fail "Can't chgrp"
+done
+sleep 2
+
+checkit "$RSYNC -rtgpvvv '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/chmod-option.test b/testsuite/chmod-option.test
new file mode 100644
index 0000000..ddf764c
--- /dev/null
+++ b/testsuite/chmod-option.test
@@ -0,0 +1,71 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that the --chmod option functions correctly.
+
+. $suitedir/rsync.fns
+
+# Build some files
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+checkdir="$scratchdir/check"
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+dir1="$fromdir/dir1"
+dir2="$fromdir/dir2"
+echo "This is the file" > "$name1"
+echo "This is the other file" > "$name2"
+mkdir "$dir1" "$dir2"
+
+chmod 4700 "$name1" || test_skipped "Can't chmod"
+chmod 700 "$dir1"
+chmod 770 "$dir2"
+
+# Copy the files we've created over to another directory
+checkit "$RSYNC -avv '$fromdir/' '$checkdir/'" "$fromdir" "$checkdir"
+
+# And then manually make the changes which should occur
+umask 002
+chmod ug-s,a+rX "$checkdir"/*
+chmod +w "$checkdir" "$checkdir"/dir*
+
+checkit "$RSYNC -avv --chmod ug-s,a+rX,D+w '$fromdir/' '$todir/'" "$checkdir" "$todir"
+
+rm -r "$fromdir" "$checkdir" "$todir"
+makepath "$todir" "$fromdir/foo"
+touch "$fromdir/bar"
+
+checkit "$RSYNC -avv '$fromdir/' '$checkdir/'" "$fromdir" "$checkdir"
+chmod o+x "$fromdir"/bar
+
+checkit "$RSYNC -avv --chmod=Fo-x '$fromdir/' '$todir/'" "$checkdir" "$todir"
+
+# Tickle a bug in rsync 2.6.8: if you push a new directory with --perms off to
+# a daemon with an incoming chmod, the daemon pretends the directory is a file
+# for the purposes of the second application of the incoming chmod.
+
+build_rsyncd_conf
+cat >>"$scratchdir/test-rsyncd.conf" <<EOF
+[test-incoming-chmod]
+	path = $todir
+	read only = no
+	incoming chmod = Fo-x
+EOF
+
+RSYNC_CONNECT_PROG="$RSYNC --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+rm -r "$todir"
+makepath "$todir"
+
+checkit "$RSYNC -avv --no-perms '$fromdir/' localhost::test-incoming-chmod/" "$checkdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/chmod-temp-dir.test b/testsuite/chmod-temp-dir.test
new file mode 100644
index 0000000..362d9d9
--- /dev/null
+++ b/testsuite/chmod-temp-dir.test
@@ -0,0 +1,41 @@
+#!/bin/sh
+
+# Copyright (C) 2004-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that various read-only and set[ug]id permissions work properly,
+# even when using a --temp-dir option (which we try to point at a
+# different filesystem than the destination dir).
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+sdev=`$TOOLDIR/getfsdev $scratchdir`
+tdev=$sdev
+
+for tmpdir2 in "${RSYNC_TEST_TMP:-/override-tmp-not-specified}" /run/shm /var/tmp /tmp; do
+    [ -d "$tmpdir2" ] && [ -w "$tmpdir2" ] || continue
+    tdev=`$TOOLDIR/getfsdev "$tmpdir2"`
+    [ x$sdev != x$tdev ] && break
+done
+
+[ x$sdev = x$tdev ] && test_skipped "Can't find a tmp dir on a different file system"
+
+chmod 440 "$fromdir/text"
+chmod 500 "$fromdir/dir/text"
+e="$fromdir/dir/subdir/foobar.baz"
+chmod 6450 "$e" || chmod 2450 "$e" || chmod 1450 "$e" || chmod 450 "$e"
+e="$fromdir/dir/subdir/subsubdir/etc-ltr-list"
+chmod 2670 "$e" || chmod 1670 "$e" || chmod 670 "$e"
+
+# First a normal copy.
+runtest "normal copy" 'checkit "$RSYNC -avv --temp-dir=\"$tmpdir2\" \"$fromdir/\" \"$todir\"" "$fromdir" "$todir"'
+
+# Then we update all the files.
+runtest "update copy" 'checkit "$RSYNC -avvI --no-whole-file --temp-dir=\"$tmpdir2\" \"$fromdir/\" \"$todir\"" "$fromdir" "$todir"'
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/chmod.test b/testsuite/chmod.test
new file mode 100644
index 0000000..1646a9c
--- /dev/null
+++ b/testsuite/chmod.test
@@ -0,0 +1,30 @@
+#!/bin/sh
+
+# Copyright (C) 2004-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that various read-only and set[ug]id permissions work properly,
+# even when using a --temp-dir option (which we try to point at a
+# different filesystem than the destination dir).
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+chmod 440 "$fromdir/text"
+chmod 500 "$fromdir/dir/text"
+e="$fromdir/dir/subdir/foobar.baz"
+chmod 6450 "$e" || chmod 2450 "$e" || chmod 1450 "$e" || chmod 450 "$e"
+e="$fromdir/dir/subdir/subsubdir/etc-ltr-list"
+chmod 2670 "$e" || chmod 1670 "$e" || chmod 670 "$e"
+
+# First a normal copy.
+runtest "normal copy" 'checkit "$RSYNC -avv \"$fromdir/\" \"$todir\"" "$fromdir" "$todir"'
+
+# Then we update all the files.
+runtest "update copy" 'checkit "$RSYNC -avvI --no-whole-file \"$fromdir/\" \"$todir\"" "$fromdir" "$todir"'
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/chown.test b/testsuite/chown.test
new file mode 100644
index 0000000..b53413e
--- /dev/null
+++ b/testsuite/chown.test
@@ -0,0 +1,86 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that when rsync is running as root and has -a it correctly sets
+# the ownership of the destination.
+
+# We don't know what users will be present on this system, so we just
+# use random numeric uids and gids.
+
+. "$suitedir/rsync.fns"
+
+case $0 in
+*fake*)
+    $RSYNC -VV | grep '"xattrs": true' >/dev/null || test_skipped "Rsync needs xattrs for fake device tests"
+    RSYNC="$RSYNC --fake-super"
+    TLS_ARGS="$TLS_ARGS --fake-super"
+    case "$HOST_OS" in
+    darwin*)
+	chown() {
+	    own=$1
+	    shift
+	    xattr -s 'rsync.%stat' "100644 0,0 $own" "${@}"
+	}
+	;;
+    solaris*)
+	chown() {
+	    own=$1
+	    shift
+	    for fn in "${@}"; do
+		runat "$fn" "$SHELL_PATH" <<EOF
+echo "100644 0,0 $own" > rsync.%stat
+EOF
+	    done
+	}
+	;;
+    freebsd*)
+	chown() {
+	    own=$1
+	    shift
+	    setextattr -h user "rsync.%stat" "100644 0,0 $own" "${@}"
+	}
+	;;
+    *)
+	chown() {
+	    own=$1
+	    shift
+	    setfattr -n 'user.rsync.%stat' -v "100644 0,0 $own" "${@}"
+	}
+	;;
+    esac
+    ;;
+*)
+    RSYNC="$RSYNC --super"
+    my_uid=`get_testuid`
+    root_uid=`get_rootuid`
+    if test x"$my_uid" = x; then
+	: # If "id" failed, try to continue...
+    elif test x"$my_uid" != x"$root_uid"; then
+	if [ -e "$FAKEROOT_PATH" ]; then
+	    echo "Let's try re-running the script under fakeroot..."
+	    exec "$FAKEROOT_PATH" "$SHELL_PATH" "$0"
+	fi
+    fi
+    ;;
+esac
+
+# Build some hardlinks
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+echo "This is the file" > "$name1"
+echo "This is the other file" > "$name2"
+
+chown 5000:5002 "$name1" || test_skipped "Can't chown (probably need root)"
+chown 5001:5003 "$name2" || test_skipped "Can't chown (probably need root)"
+
+cd "$fromdir/.."
+checkit "$RSYNC -aHvv from/ to/" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/crtimes.test b/testsuite/crtimes.test
new file mode 100644
index 0000000..456f0a5
--- /dev/null
+++ b/testsuite/crtimes.test
@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Test rsync copying create times
+
+. "$suitedir/rsync.fns"
+
+$RSYNC -VV | grep '"crtimes": true' >/dev/null || test_skipped "Rsync is configured without crtimes support"
+
+# Setting an older time via touch sets the create time to the mtime.
+# Setting it to a newer time affects just the mtime.
+
+mkdir "$fromdir"
+echo hiho >"$fromdir/foo"
+
+touch -t 200101011111.11 "$fromdir"
+touch -t 200202022222.22 "$fromdir"
+
+touch -t 200111111111.11 "$fromdir/foo"
+touch -t 200212122222.22 "$fromdir/foo"
+
+TLS_ARGS=--crtimes
+
+checkit "$RSYNC -rtgvvv --crtimes \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/daemon-gzip-download.test b/testsuite/daemon-gzip-download.test
new file mode 100644
index 0000000..57dd820
--- /dev/null
+++ b/testsuite/daemon-gzip-download.test
@@ -0,0 +1,37 @@
+#!/bin/sh
+
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+
+#    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 2 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, write to the Free Software
+#    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+# This test tries to download a tree over a compressed connection from
+# the server.  This ought to exercise (exorcise?) a bug in 2.5.3.
+
+. "$suitedir/rsync.fns"
+
+build_rsyncd_conf
+
+RSYNC_CONNECT_PROG="$RSYNC --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+hands_setup
+
+# Build chkdir with a normal rsync and an --exclude.
+$RSYNC -av --exclude=foobar.baz "$fromdir/" "$chkdir/"
+
+checkit "$RSYNC -avvvvzz localhost::test-from/ '$todir/'" "$chkdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/daemon-gzip-upload.test b/testsuite/daemon-gzip-upload.test
new file mode 100644
index 0000000..b2110ea
--- /dev/null
+++ b/testsuite/daemon-gzip-upload.test
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING)
+
+# We don't really want to start the server listening, because that
+# might interfere with the security or operation of the test machine.
+# Instead we use the fake-connect feature to dynamically assign a pair
+# of ports.
+
+# This test tries to upload a file over a compressed connection to the
+# server.  This ought to exercise (exorcise?) a bug in 2.5.3.
+
+. "$suitedir/rsync.fns"
+
+build_rsyncd_conf
+
+RSYNC_CONNECT_PROG="$RSYNC --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+hands_setup
+
+# Build chkdir with a normal rsync and an --exclude.
+$RSYNC -av --exclude=foobar.baz "$fromdir/" "$chkdir/"
+
+checkit "'$ignore23' $RSYNC -avvvvzz '$fromdir/' localhost::test-to/" "$chkdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/daemon.test b/testsuite/daemon.test
new file mode 100644
index 0000000..60aa334
--- /dev/null
+++ b/testsuite/daemon.test
@@ -0,0 +1,90 @@
+#!/bin/sh
+
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING)
+
+# We don't really want to start the server listening, because that
+# might interfere with the security or operation of the test machine.
+# Instead we use the fake-connect feature to dynamically assign a pair
+# of ports.
+
+# Having started the server we try some basic operations against it:
+
+# getting a list of module
+# listing files in a module
+# retrieving a module
+# uploading to a module
+# checking the log file
+# password authentication
+
+. "$suitedir/rsync.fns"
+
+SSH="src/support/lsh.sh --no-cd"
+FILE_REPL='s/^\([^d][^ ]*\) *\(..........[0-9]\) /\1 \2 /'
+DIR_REPL='s/^\(d[^ ]*\)  *[0-9][.,0-9]* /\1         DIR /'
+LS_REPL='s;[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9] ;####/##/## ##:##:## ;g'
+
+build_rsyncd_conf
+
+makepath "$fromdir/foo" "$fromdir/bar/baz"
+makepath "$todir"
+echo one >"$fromdir/foo/one"
+echo two >"$fromdir/bar/two"
+echo three >"$fromdir/bar/baz/three"
+
+cd "$scratchdir"
+
+ln -s test-rsyncd.conf rsyncd.conf
+
+my_uid=`get_testuid`
+root_uid=`get_rootuid`
+confopt=''
+if test x"$my_uid" = x"$root_uid"; then
+    # Root needs to specify the config file, or it uses /etc/rsyncd.conf.
+    echo "Forcing --config=$conf"
+    confopt=" --config=$conf"
+fi
+
+# These have a space-padded 15-char name, then a tab, then a comment.
+sed 's/NOCOMMENT//' <<EOT >"$chkfile"
+test-from      	r/o
+test-to        	r/w
+test-scratch   	NOCOMMENT
+EOT
+
+checkdiff2 "$RSYNC -ve '$SSH' --rsync-path='$RSYNC$confopt' localhost::"
+echo '===='
+
+RSYNC_CONNECT_PROG="$RSYNC --config=$conf --daemon"
+export RSYNC_CONNECT_PROG
+
+checkdiff2 "$RSYNC -v localhost::"
+echo '===='
+
+checkdiff "$RSYNC -r localhost::test-hidden" \
+	"sed -e '$FILE_REPL' -e '$DIR_REPL' -e '$LS_REPL'" <<EOT
+drwxr-xr-x         DIR ####/##/## ##:##:## .
+drwxr-xr-x         DIR ####/##/## ##:##:## bar
+-rw-r--r--           4 ####/##/## ##:##:## bar/two
+drwxr-xr-x         DIR ####/##/## ##:##:## bar/baz
+-rw-r--r--           6 ####/##/## ##:##:## bar/baz/three
+drwxr-xr-x         DIR ####/##/## ##:##:## foo
+-rw-r--r--           4 ####/##/## ##:##:## foo/one
+EOT
+
+checkdiff "$RSYNC -r localhost::test-from/f*" \
+	"sed -e '$FILE_REPL' -e '$DIR_REPL' -e '$LS_REPL'" <<EOT
+drwxr-xr-x         DIR ####/##/## ##:##:## foo
+-rw-r--r--           4 ####/##/## ##:##:## foo/one
+EOT
+diff $diffopt "$chkfile" "$outfile" || test_fail "test 3 failed"
+
+if $RSYNC -VV | grep '"atimes": true' >/dev/null; then
+    checkdiff "$RSYNC -rU localhost::test-from/f*" \
+	"sed -e '$FILE_REPL' -e '$DIR_REPL' -e '$LS_REPL'" <<EOT
+drwxr-xr-x         DIR ####/##/## ##:##:##                     foo
+-rw-r--r--           4 ####/##/## ##:##:## ####/##/## ##:##:## foo/one
+EOT
+fi
diff --git a/testsuite/delay-updates.test b/testsuite/delay-updates.test
new file mode 100644
index 0000000..3b6226b
--- /dev/null
+++ b/testsuite/delay-updates.test
@@ -0,0 +1,21 @@
+#!/bin/sh
+
+# Test rsync --delay-updates
+
+. "$suitedir/rsync.fns"
+
+mkdir "$fromdir"
+
+echo 1 > "$fromdir/foo"
+
+checkit "$RSYNC -aiv --delay-updates \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+mkdir "$todir/.~tmp~"
+echo 2 > "$todir/.~tmp~/foo"
+touch -r .. "$todir/.~tmp~/foo" "$todir/foo"
+echo 3 > "$fromdir/foo"
+
+checkit "$RSYNC -aiv --delay-updates \"$fromdir/\" \"$todir/\"" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/delete.test b/testsuite/delete.test
new file mode 100644
index 0000000..2a9df7c
--- /dev/null
+++ b/testsuite/delete.test
@@ -0,0 +1,57 @@
+#!/bin/sh
+
+# Copyright (C) 2005-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of various delete directives.
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+makepath "$chkdir" "$todir/extradir" "$todir/emptydir/subdir"
+
+echo extra >"$todir"/remove1
+echo extra >"$todir"/remove2
+echo extra >"$todir"/extradir/remove3
+echo extra >"$todir"/emptydir/subdir/remove4
+
+# Create two chk dirs, one with a copy of the source files, and one with
+# what we expect to be left behind by the copy using --remove-source-files.
+# Also, make sure that --dry-run --del doesn't output anything extraneous.
+$RSYNC -av "$fromdir/" "$chkdir/copy/" >"$tmpdir/copy.out" 2>&1
+cat "$tmpdir/copy.out"
+grep -E -v '^(created directory|sent|total size) ' "$tmpdir/copy.out" >"$tmpdir/copy.new"
+mv "$tmpdir/copy.new" "$tmpdir/copy.out"
+
+$RSYNC -avn --del "$fromdir/" "$chkdir/copy2/" >"$tmpdir/copy2.out" 2>&1 || true
+cat "$tmpdir/copy2.out"
+grep -E -v '^(created directory|sent|total size) ' "$tmpdir/copy2.out" >"$tmpdir/copy2.new"
+mv "$tmpdir/copy2.new" "$tmpdir/copy2.out"
+
+diff $diffopt "$tmpdir/copy.out" "$tmpdir/copy2.out"
+
+$RSYNC -av -f 'exclude,! */' "$fromdir/" "$chkdir/empty/"
+
+checkit "$RSYNC -avv --del --remove-source-files '$fromdir/' '$todir/'" "$chkdir/copy" "$todir"
+
+diff -r "$chkdir/empty" "$fromdir"
+
+# Make sure that "P" but not "-" per-dir merge-file filters take effect with
+# --delete-excluded.
+cat >"$todir/filters" <<EOF
+P foo
+- bar
+EOF
+touch "$todir/foo" "$todir/bar" "$todir/baz"
+
+$RSYNC -r --exclude=baz --filter=': filters' --delete-excluded "$fromdir/" "$todir/"
+
+test -f "$todir/foo" || test_fail "rsync should NOT have deleted $todir/foo"
+test -f "$todir/bar" && test_fail "rsync SHOULD have deleted $todir/bar"
+test -f "$todir/baz" && test_fail "rsync SHOULD have deleted $todir/baz"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/devices.test b/testsuite/devices.test
new file mode 100644
index 0000000..ad5f936
--- /dev/null
+++ b/testsuite/devices.test
@@ -0,0 +1,171 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of devices.  This can only run if you're root.
+
+. "$suitedir/rsync.fns"
+
+# Build some hardlinks
+
+case $0 in
+*fake*)
+    $RSYNC -VV | grep '"xattrs": true' >/dev/null || test_skipped "Rsync needs xattrs for fake device tests"
+    RSYNC="$RSYNC --fake-super"
+    TLS_ARGS="$TLS_ARGS --fake-super"
+    case "$HOST_OS" in
+    darwin*)
+	mknod() {
+	    fn="$1"
+	    case "$2" in
+	    p) mode=10644 ;;
+	    c) mode=20644 ;;
+	    b) mode=60644 ;;
+	    esac
+	    maj="${3:-0}"
+	    min="${4:-0}"
+	    touch "$fn"
+	    xattr -s 'rsync.%stat' "$mode $maj,$min 0:0" "$fn"
+	}
+	;;
+    solaris*)
+	mknod() {
+	    fn="$1"
+	    case "$2" in
+	    p) mode=10644 ;;
+	    c) mode=20644 ;;
+	    b) mode=60644 ;;
+	    esac
+	    maj="${3:-0}"
+	    min="${4:-0}"
+	    touch "$fn"
+	    runat "$fn" "$SHELL_PATH" <<EOF
+echo "$mode $maj,$min 0:0" > rsync.%stat
+EOF
+	}
+	;;
+    freebsd*)
+	mknod() {
+	    fn="$1"
+	    case "$2" in
+	    p) mode=10644 ;;
+	    c) mode=20644 ;;
+	    b) mode=60644 ;;
+	    esac
+	    maj="${3:-0}"
+	    min="${4:-0}"
+	    touch "$fn"
+	    setextattr -h user "rsync.%stat" "$mode $maj,$min 0:0" "$fn"
+	}
+	;;
+    *)
+	mknod() {
+	    fn="$1"
+	    case "$2" in
+	    p) mode=10644 ;;
+	    c) mode=20644 ;;
+	    b) mode=60644 ;;
+	    esac
+	    maj="${3:-0}"
+	    min="${4:-0}"
+	    touch "$fn"
+	    setfattr -n 'user.rsync.%stat' -v "$mode $maj,$min 0:0" "$fn"
+	}
+	;;
+    esac
+    ;;
+*)
+    my_uid=`get_testuid`
+    root_uid=`get_rootuid`
+    if test x"$my_uid" = x; then
+	: # If "id" failed, try to continue...
+    elif test x"$my_uid" != x"$root_uid"; then
+	if [ -e "$FAKEROOT_PATH" ]; then
+	    echo "Let's try re-running the script under fakeroot..."
+	    exec "$FAKEROOT_PATH" "$SHELL_PATH" $RUNSHFLAGS "$0"
+	fi
+	test_skipped "Rsync needs root/fakeroot for device tests"
+    fi
+    ;;
+esac
+
+# TODO: Need to test whether hardlinks are possible on this OS/filesystem
+
+$RSYNC -VV | grep '"hardlink_specials": true' >/dev/null && CAN_HLINK_SPECIAL=yes || CAN_HLINK_SPECIAL=no
+
+mkdir "$fromdir"
+mkdir "$todir"
+mknod "$fromdir/char" c 41 67  || test_skipped "Can't create char device node"
+mknod "$fromdir/char2" c 42 68  || test_skipped "Can't create char device node"
+mknod "$fromdir/char3" c 42 69  || test_skipped "Can't create char device node"
+mknod "$fromdir/block" b 42 69 || test_skipped "Can't create block device node"
+mknod "$fromdir/block2" b 42 73 || test_skipped "Can't create block device node"
+mknod "$fromdir/block3" b 105 73 || test_skipped "Can't create block device node"
+if test "$CAN_HLINK_SPECIAL" = yes; then
+    ln "$fromdir/block3" "$fromdir/block3.5"
+else
+    echo "Skipping hard-linked device test..."
+fi
+mkfifo "$fromdir/fifo" || mknod "$fromdir/fifo" p || test_skipped "Can't run mkfifo"
+# Work around time rounding/truncating issue by touching both files.
+touch -r "$fromdir/block" "$fromdir/block" "$fromdir/block2"
+
+checkdiff "$RSYNC -ai '$fromdir/block' '$todir/block2'" <<EOT
+cD$all_plus block
+EOT
+
+checkdiff "$RSYNC -ai '$fromdir/block2' '$todir/block'" <<EOT
+cD$all_plus block2
+EOT
+
+sleep 1
+
+checkdiff "$RSYNC -Di '$fromdir/block3' '$todir/block'" <<EOT
+cDc.T.$dots block3
+EOT
+
+cat >"$chkfile" <<EOT
+.d..t.$dots ./
+cDc.t.$dots block
+cDc...$dots block2
+cD$all_plus block3
+hD$all_plus block3.5 => block3
+cD$all_plus char
+cD$all_plus char2
+cD$all_plus char3
+cS$all_plus fifo
+EOT
+if test "$CAN_HLINK_SPECIAL" = no; then
+    grep -v block3.5 <"$chkfile" >"$chkfile.new"
+    mv "$chkfile.new" "$chkfile"
+fi
+
+checkdiff2 "$RSYNC -aiHvv '$fromdir/' '$todir/'" v_filt
+
+echo "check how the directory listings compare with diff:"
+echo ""
+( cd "$fromdir" && rsync_ls_lR . ) > "$tmpdir/ls-from"
+( cd "$todir" && rsync_ls_lR . ) > "$tmpdir/ls-to"
+diff $diffopt "$tmpdir/ls-from" "$tmpdir/ls-to"
+
+if test "$CAN_HLINK_SPECIAL" = yes; then
+    set -x
+    checkdiff "$RSYNC -aii --link-dest='$todir' '$fromdir/' '$chkdir/'" <<EOT
+created directory $chkdir
+cd$allspace ./
+hD$allspace block
+hD$allspace block2
+hD$allspace block3
+hD$allspace block3.5
+hD$allspace char
+hD$allspace char2
+hD$allspace char3
+hS$allspace fifo
+EOT
+fi
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/dir-sgid.test b/testsuite/dir-sgid.test
new file mode 100644
index 0000000..d6b9a3c
--- /dev/null
+++ b/testsuite/dir-sgid.test
@@ -0,0 +1,48 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync obeys directory setgid. -- Matt McCutchen
+
+. $suitedir/rsync.fns
+
+umask 077
+
+# Call as: testit <dirname> <dirperms> <file-expected> <program-expected> <dir-expected>
+testit() {
+    todir="$scratchdir/$1"
+    mkdir "$todir"
+    chmod $2 "$todir"
+    # Make sure we obey directory setgid when creating a directory to hold multiple transferred files,
+    # even though the directory itself is outside the transfer
+    $RSYNC -rvv "$scratchdir/dir" "$scratchdir/file" "$scratchdir/program" "$todir/to/"
+    check_perms "$todir/to" $5 "Target $1"
+    check_perms "$todir/to/dir" $5 "Target $1"
+    check_perms "$todir/to/file" $3 "Target $1"
+    check_perms "$todir/to/program" $4 "Target $1"
+}
+
+mkdir "$scratchdir/dir"
+# Cygwin has a persistent default dir ACL that ruins this test.
+case `getfacl "$scratchdir/dir" 2>/dev/null || true` in
+*default:user::*) test_skipped "The default ACL mode interferes with this test" ;;
+esac
+
+echo "File!" >"$scratchdir/file"
+echo "#!/bin/sh" >"$scratchdir/program"
+
+chmod u=rwx,g=rw,g+s,o=r "$scratchdir/dir" || test_skipped "Can't chmod"
+chmod 664 "$scratchdir/file"
+chmod 775 "$scratchdir/program"
+
+[ -g "$scratchdir/dir" ] || test_skipped "The directory setgid bit vanished!"
+mkdir "$scratchdir/dir/blah"
+[ -g "$scratchdir/dir/blah" ] || test_skipped "Your filesystem doesn't use directory setgid; maybe it's BSD."
+
+# Test some target directories
+testit setgid-off 700 rw------- rwx------ rwx------
+testit setgid-on u=rwx,g=rw,g+s,o-rwx rw------- rwx------ rwx--S---
+
+# Hooray
+exit 0
diff --git a/testsuite/duplicates.test b/testsuite/duplicates.test
new file mode 100644
index 0000000..3317e72
--- /dev/null
+++ b/testsuite/duplicates.test
@@ -0,0 +1,44 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of duplicate filenames.
+
+# It's quite possible that the user might specify the same source file
+# more than once on the command line, perhaps through shell variables
+# or wildcard expansions.  It might cause problems for rsync if the
+# same name occurred more than once in the file list, because we might
+# be trying to update the first copy and generate checksums for the
+# second copy at the same time.  See clean_flist() for the implementation.
+
+# We don't need to worry about hardlinks or symlinks.  Because we
+# always rename-and-replace the new copy, they can't affect us.
+
+# This test is not great, because it is a timing-dependent bug.
+
+. "$suitedir/rsync.fns"
+
+# Build some hardlinks
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+echo "This is the file" > "$name1"
+ln -s "$name1" "$name2" || test_fail "can't create symlink"
+
+checkit "$RSYNC -avv '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$fromdir/' '$todir/'" "$fromdir" "$todir" \
+    | tee "$outfile"
+
+# Make sure each file was only copied once...
+if [ `grep -c '^name1$' "$outfile"` != 1 ]; then
+    test_fail "name1 was not copied exactly once"
+fi
+if [ `grep -c '^name2 -> ' "$outfile"` != 1 ]; then
+    test_fail "name2 was not copied exactly once"
+fi
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/exclude-lsh.test b/testsuite/exclude-lsh.test
new file mode 120000
index 0000000..84bc98a
--- /dev/null
+++ b/testsuite/exclude-lsh.test
@@ -0,0 +1 @@
+exclude.test
\ No newline at end of file
diff --git a/testsuite/exclude.test b/testsuite/exclude.test
new file mode 100644
index 0000000..56b68b8
--- /dev/null
+++ b/testsuite/exclude.test
@@ -0,0 +1,252 @@
+#!/bin/sh
+
+# Copyright (C) 2003-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of exclude/include directives.
+
+# Test some of the more obscure wildcard handling of exclude/include
+# processing.
+
+. "$suitedir/rsync.fns"
+
+CVSIGNORE='*.junk'
+export CVSIGNORE
+
+case $0 in
+*-lsh.*)
+    RSYNC_RSH="$scratchdir/src/support/lsh.sh"
+    export RSYNC_RSH
+    rpath=" --rsync-path='$RSYNC'"
+    host='lh:'
+    ;;
+*)
+    rpath=''
+    host=''
+    ;;
+esac
+
+# Build some files/dirs/links to copy
+
+makepath "$fromdir/foo/down/to/you"
+makepath "$fromdir/foo/sub"
+makepath "$fromdir/bar/down/to/foo/too"
+makepath "$fromdir/bar/down/to/bar/baz"
+makepath "$fromdir/mid/for/foo/and/that/is/who"
+makepath "$fromdir/new/keep/this"
+makepath "$fromdir/new/lose/this"
+cat >"$fromdir/.filt" <<EOF
+exclude down
+: .filt-temp
+clear
+- .filt
+- *.bak
+- *.old
+EOF
+echo filtered-1 >"$fromdir/foo/file1"
+echo removed >"$fromdir/foo/file2"
+echo cvsout >"$fromdir/foo/file2.old"
+cat >"$fromdir/foo/.filt" <<EOF
+include .filt
+- /file1
+EOF
+echo not-filtered-1 >"$fromdir/foo/sub/file1"
+cat >"$fromdir/bar/.filt" <<EOF
+- home-cvs-exclude
+dir-merge .filt2
++ to
+EOF
+echo cvsout >"$fromdir/bar/down/to/home-cvs-exclude"
+cat >"$fromdir/bar/down/to/.filt2" <<EOF
+- .filt2
+EOF
+cat >"$fromdir/bar/down/to/foo/.filt2" <<EOF
++ *.junk
+EOF
+echo keeper >"$fromdir/bar/down/to/foo/file1"
+echo cvsout >"$fromdir/bar/down/to/foo/file1.bak"
+echo gone >"$fromdir/bar/down/to/foo/file3"
+echo lost >"$fromdir/bar/down/to/foo/file4"
+echo weird >"$fromdir/bar/down/to/foo/+ file3"
+echo cvsout-but-filtin >"$fromdir/bar/down/to/foo/file4.junk"
+echo smashed >"$fromdir/bar/down/to/foo/to"
+cat >"$fromdir/bar/down/to/bar/.filt2" <<EOF
+- *.deep
+EOF
+echo filtout >"$fromdir/bar/down/to/bar/baz/file5.deep"
+# This one should be ineffectual
+cat >"$fromdir/mid/.filt2" <<EOF
+- extra
+EOF
+echo cvsout >"$fromdir/mid/one-in-one-out"
+echo one-in-one-out >"$fromdir/mid/.cvsignore"
+echo cvsin >"$fromdir/mid/one-for-all"
+cat >"$fromdir/mid/.filt" <<EOF
+:C
+EOF
+echo cvsin >"$fromdir/mid/for/one-in-one-out"
+echo expunged >"$fromdir/mid/for/foo/extra"
+echo retained >"$fromdir/mid/for/foo/keep"
+
+# Setup our test exclude/include files.
+
+excl="$scratchdir/exclude-from"
+cat >"$excl" <<EOF
+!
+# If the second line of these two lines does anything, it's a bug.
++ **/bar
+- /bar
+# This should match against the whole path, not just the name.
++ foo**too
+# These should float at the end of the path.
++ foo/s?b/
+- foo/*/
+# Test how /** differs from /***
+- new/keep/**
+- new/lose/***
+# Test some normal excludes.  Competing lines are paired.
++ t[o]/
+- to
++ file4
+- file[2-9]
+- /mid/for/foo/extra
+EOF
+
+cat >"$scratchdir/.cvsignore" <<EOF
+home-cvs-exclude
+EOF
+
+# Start with a check of --prune-empty-dirs:
+$RSYNC -av --rsync-path="$RSYNC" -f -_foo/too/ -f -_foo/down/ -f -_foo/and/ -f -_new/ "$host$fromdir/" "$chkdir/"
+checkit "$RSYNC -av$rpath --prune-empty-dirs '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+rm -rf "$todir"
+
+# Add a directory symlink.
+ln -s too "$fromdir/bar/down/to/foo/sym"
+
+# Start to prep an --update test dir
+mkdir "$scratchdir/up1" "$scratchdir/up2"
+touch "$scratchdir/up1/dst-newness" "$scratchdir/up2/src-newness"
+touch "$scratchdir/up1/same-newness" "$scratchdir/up2/same-newness"
+touch "$scratchdir/up1/extra-src" "$scratchdir/up2/extra-dest"
+
+# Create chkdir with what we expect to be excluded.
+checkit "$RSYNC -avv$rpath '$host$fromdir/' '$chkdir/'" "$fromdir" "$chkdir"
+sleep 1 # Ensures that the rm commands will tweak the directory times.
+rm -r "$chkdir"/foo/down
+rm -r "$chkdir"/mid/for/foo/and
+rm -r "$chkdir"/new/keep/this
+rm -r "$chkdir"/new/lose
+rm "$chkdir"/foo/file[235-9]
+rm "$chkdir"/bar/down/to/foo/to "$chkdir"/bar/down/to/foo/file[235-9]
+rm "$chkdir"/mid/for/foo/extra
+
+# Finish prep for the --update test (run last)
+touch "$scratchdir/up1/src-newness" "$scratchdir/up2/dst-newness"
+
+# Un-tweak the directory times in our first (weak) exclude test (though
+# it's a good test of the --existing option).
+$RSYNC -av --rsync-path="$RSYNC" --existing --include='*/' --exclude='*' "$host$fromdir/" "$chkdir/"
+
+# Now, test if rsync excludes the same files.
+
+checkit "$RSYNC -avv$rpath --exclude-from='$excl' \
+    --delete-during '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+# Modify the chk dir by removing cvs-ignored files and then tweaking the dir times.
+
+rm "$chkdir"/foo/*.old
+rm "$chkdir"/bar/down/to/foo/*.bak
+rm "$chkdir"/bar/down/to/foo/*.junk
+rm "$chkdir"/bar/down/to/home-cvs-exclude
+rm "$chkdir"/mid/one-in-one-out
+
+$RSYNC -av --rsync-path="$RSYNC" --existing --filter='exclude,! */' "$host$fromdir/" "$chkdir/"
+
+# Now, test if rsync excludes the same files, this time with --cvs-exclude
+# and --delete-excluded.
+
+# The -C option gets applied in a different order when pushing & pulling, so we instead
+# add the 2 --cvs-exclude filter rules (":C" & "-C") via -f to keep the order the same.
+checkit "$RSYNC -avv$rpath --filter='merge $excl' -f:C -f-C --delete-excluded \
+    --delete-during '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+# Modify the chk dir for our merge-exclude test and then tweak the dir times.
+
+rm "$chkdir"/foo/file1
+rm "$chkdir"/bar/down/to/bar/baz/*.deep
+cp_touch "$fromdir"/bar/down/to/foo/*.junk "$chkdir"/bar/down/to/foo
+cp_touch "$fromdir"/bar/down/to/foo/to "$chkdir"/bar/down/to/foo
+
+$RSYNC -av --rsync-path="$RSYNC" --existing -f 'show .filt*' -f 'hide,! */' --del "$host$fromdir/" "$todir/"
+
+echo retained >"$todir"/bar/down/to/bar/baz/nodel.deep
+cp_touch "$todir"/bar/down/to/bar/baz/nodel.deep "$chkdir"/bar/down/to/bar/baz
+
+$RSYNC -av --rsync-path="$RSYNC" --existing --filter='-! */' "$host$fromdir/" "$chkdir/"
+
+# Now, test if rsync excludes the same files, this time with a merge-exclude
+# file.
+
+checkit "sed '/!/d' '$excl' |
+    $RSYNC -avv$rpath -f dir-merge_.filt -f merge_- \
+    --delete-during '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+# Remove the files that will be deleted.
+
+rm "$chkdir"/.filt
+rm "$chkdir"/bar/.filt
+rm "$chkdir"/bar/down/to/.filt2
+rm "$chkdir"/bar/down/to/foo/.filt2
+rm "$chkdir"/bar/down/to/bar/.filt2
+rm "$chkdir"/mid/.filt
+
+$RSYNC -av --rsync-path="$RSYNC" --existing --include='*/' --exclude='*' "$host$fromdir/" "$chkdir/"
+
+# Now, try the prior command with --delete-before and some side-specific
+# rules.
+
+checkit "sed '/!/d' '$excl' |
+    $RSYNC -avv$rpath -f :s_.filt -f .s_- -f P_nodel.deep \
+    --delete-before '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+# Next, we'll test some rule-restricted filter files.
+
+cat >"$fromdir/bar/down/.excl" <<EOF
+file3
+EOF
+cat >"$fromdir/bar/down/to/foo/.excl" <<EOF
++ file3
+*.bak
+EOF
+$RSYNC -av --rsync-path="$RSYNC" --del "$host$fromdir/" "$chkdir/"
+rm "$chkdir/bar/down/to/foo/file1.bak"
+rm "$chkdir/bar/down/to/foo/file3"
+rm "$chkdir/bar/down/to/foo/+ file3"
+$RSYNC -av --rsync-path="$RSYNC" --existing --filter='-! */' "$host$fromdir/" "$chkdir/"
+$RSYNC -av --rsync-path="$RSYNC" --delete-excluded --exclude='*' "$host$fromdir/" "$todir/"
+
+checkit "$RSYNC -avv$rpath -f dir-merge,-_.excl \
+    '$host$fromdir/' '$todir/'" "$chkdir" "$todir"
+
+relative_opts='--relative --chmod=Du+w --copy-unsafe-links'
+$RSYNC -av --rsync-path="$RSYNC" $relative_opts "$host$fromdir/foo" "$chkdir/"
+rm -rf "$chkdir$fromdir/foo/down"
+$RSYNC -av $relative_opts --existing --filter='-! */' "$fromdir/foo" "$chkdir/"
+
+checkit "$RSYNC -avv$rpath $relative_opts --exclude='$fromdir/foo/down' \
+    '$host$fromdir/foo' '$todir'" "$chkdir$fromdir/foo" "$todir$fromdir/foo"
+
+# Now we'll test the --update option.
+checkdiff "$RSYNC -aiiO$rpath --update --info=skip '$host$scratchdir/up1/' '$scratchdir/up2/'" \
+	"grep -v '^\.d$allspace'" <<EOT
+dst-newness is newer
+>f$all_plus extra-src
+.f$allspace same-newness
+>f..t.$dots src-newness
+EOT
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/executability.test b/testsuite/executability.test
new file mode 100644
index 0000000..8f09d8f
--- /dev/null
+++ b/testsuite/executability.test
@@ -0,0 +1,47 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test the --executability or -E option. -- Matt McCutchen
+
+. $suitedir/rsync.fns
+
+# Put some files in the From directory
+mkdir "$fromdir"
+cat <<EOF >"$fromdir/1"
+#!/bin/sh
+echo 'Program One!'
+EOF
+cat <<EOF >"$fromdir/2"
+#!/bin/sh
+echo 'Program Two!'
+EOF
+
+chmod 1700 "$fromdir/1" || test_skipped "Can't chmod"
+chmod 600 "$fromdir/2"
+
+$RSYNC -rvv "$fromdir/" "$todir/"
+
+check_perms "$todir/1" rwx------ 1
+check_perms "$todir/2" rw------- 1
+
+# Mix up the permissions a bit
+chmod 600 "$fromdir/1"
+chmod 601 "$fromdir/2"
+chmod 604 "$todir/2"
+
+$RSYNC -rvv "$fromdir/" "$todir/"
+
+# No -E, so nothing should have changed
+check_perms "$todir/1" rwx------ 2
+check_perms "$todir/2" rw----r-- 2
+
+$RSYNC -rvvE "$fromdir/" "$todir/"
+
+# Now things should have happened!
+check_perms "$todir/1" rw------- 3
+check_perms "$todir/2" rwx---r-x 3
+
+# Hooray
+exit 0
diff --git a/testsuite/files-from.test b/testsuite/files-from.test
new file mode 100644
index 0000000..207eab5
--- /dev/null
+++ b/testsuite/files-from.test
@@ -0,0 +1,45 @@
+#!/bin/sh
+
+# Copyright (C) 2008-2020 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that --files-from=FILE works right.
+
+. "$suitedir/rsync.fns"
+
+SSH="$scratchdir/src/support/lsh.sh"
+
+hands_setup
+
+# This list of files skips the contents of "subsubdir" but includes
+# the contents of "subsubdir2" due to its trailing slash.
+cat >"$scratchdir/filelist" <<EOT
+from/./
+from/./dir/subdir
+from/./dir/subdir/subsubdir
+from/./dir/subdir/subsubdir2/
+from/./dir/subdir/foobar.baz
+EOT
+
+# Create a chkdir without the content that we expect to be omitted.
+$RSYNC -a --exclude=dir/text --exclude='subsubdir/**' "$fromdir/" "$chkdir/"
+
+checkit "$RSYNC -av --files-from='$scratchdir/filelist' '$scratchdir' '$todir/'" "$chkdir" "$todir"
+
+for filehost in '' 'localhost:'; do
+    for srchost in '' 'localhost:'; do
+	if [ -z "$srchost" ]; then
+	    desthost='localhost:'
+	else
+	    desthost=''
+	fi
+
+	rm -rf "$todir"
+	checkit "$RSYNC -avse '$SSH' --rsync-path='$RSYNC' --files-from='$filehost$scratchdir/filelist' '$srchost$scratchdir' '$desthost$todir/'" "$chkdir" "$todir"
+    done
+done
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/fuzzy.test b/testsuite/fuzzy.test
new file mode 100644
index 0000000..101ffd3
--- /dev/null
+++ b/testsuite/fuzzy.test
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+# Copyright (C) 2005-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of the --fuzzy option.
+
+. "$suitedir/rsync.fns"
+
+mkdir "$fromdir"
+mkdir "$todir"
+
+cp_p "$srcdir"/rsync.c "$fromdir"/rsync.c
+cp_touch "$fromdir"/rsync.c "$todir"/rsync2.c
+sleep 1
+
+# Let's do it!
+checkit "$RSYNC -avvi --no-whole-file --fuzzy --delete-delay \
+    '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/hands.test b/testsuite/hands.test
new file mode 100644
index 0000000..8e265b7
--- /dev/null
+++ b/testsuite/hands.test
@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# Copyright (C) 1998, 1999 by Philip Hands <phil@hands.com>
+# Copyright (C) 2001, 2002 by Martin Pool <mbp@samba.org>
+#
+# This program is distributable under the terms of the GNU GPL (see COPYING)
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+DEBUG_OPTS="--debug=all0,deltasum0"
+
+# Main script starts here
+
+runtest "basic operation" 'checkit "$RSYNC -av \"$fromdir/\" \"$todir\"" "$fromdir/" "$todir"'
+
+ln "$fromdir/filelist" "$fromdir/dir"
+runtest "hard links" 'checkit "$RSYNC -avH --bwlimit=0 $DEBUG_OPTS \"$fromdir/\" \"$todir\"" "$fromdir/" "$todir"'
+
+rm "$todir/text"
+runtest "one file" 'checkit "$RSYNC -avH $DEBUG_OPTS \"$fromdir/\" \"$todir\"" "$fromdir/" "$todir"'
+
+echo "extra line" >> "$todir/text"
+runtest "extra data" 'checkit "$RSYNC -avH $DEBUG_OPTS --no-whole-file \"$fromdir/\" \"$todir\"" "$fromdir/" "$todir"'
+
+cp "$fromdir/text" "$todir/ThisShouldGo"
+runtest " --delete" 'checkit "$RSYNC --delete -avH $DEBUG_OPTS \"$fromdir/\" \"$todir\"" "$fromdir/" "$todir"'
+
+cd "$tmpdir"
+rm -rf to from/*dir
+
+# Do the real copy, touch up the parent-dir's time, and then check the copy.
+$RSYNC -av from/* to/
+checkit "$RSYNC -av --exclude='*' from/ to/" "$fromdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/hardlinks.test b/testsuite/hardlinks.test
new file mode 100644
index 0000000..af2ea40
--- /dev/null
+++ b/testsuite/hardlinks.test
@@ -0,0 +1,81 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync handling of hardlinks.  By default, rsync does not detect
+# hard links and they get sent as separate files.  If you specify -H,
+# then hard links are detected and linked together on the receiver.
+
+. "$suitedir/rsync.fns"
+
+SSH="$scratchdir/src/support/lsh.sh"
+
+# Build some hardlinks
+
+fromdir="$scratchdir/from"
+todir="$scratchdir/to"
+
+# TODO: Need to test whether hardlinks are possible on this OS/filesystem
+
+mkdir "$fromdir"
+name1="$fromdir/name1"
+name2="$fromdir/name2"
+name3="$fromdir/name3"
+name4="$fromdir/name4"
+echo "This is the file" > "$name1"
+ln "$name1" "$name2" || test_skipped "Can't create hardlink"
+ln "$name2" "$name3" || test_fail "Can't create hardlink"
+cp "$name2" "$name4" || test_fail "Can't copy file"
+cat $srcdir/*.c >"$fromdir/text"
+
+checkit "$RSYNC -aHivv --debug=HLINK5 '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+echo "extra extra" >>"$todir/name1"
+
+checkit "$RSYNC -aHivv --debug=HLINK5 --no-whole-file '$fromdir/' '$todir/'" "$fromdir" "$todir"
+
+# Add a new link in a new subdirectory to test that we don't try to link
+# the files before the directory gets created.  We also create a bunch of
+# extra files to ensure that an incremental-recursion transfer works across
+# distant files.
+makepath "$fromdir/subdir/down/deep"
+
+files=''
+for x in a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9; do
+    for y in a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9; do
+	files="$files $x$y"
+    done
+done
+(cd "$fromdir/subdir"; touch $files)
+
+ln "$name1" "$fromdir/subdir/down/deep/new-file"
+rm "$todir/text"
+
+checkit "$RSYNC -aHivve '$SSH' --debug=HLINK5 --rsync-path='$RSYNC' '$fromdir/' localhost:'$todir/'" "$fromdir" "$todir"
+
+# Do some duplicate copies using --link-dest and --copy-dest to test that
+# we hard-link all locally-inherited items.
+checkit "$RSYNC -aHivv --debug=HLINK5 --link-dest='$todir' '$fromdir/' '$chkdir/'" "$todir" "$chkdir"
+
+rm -rf "$chkdir"
+checkit "$RSYNC -aHivv --debug=HLINK5 --copy-dest='$todir' '$fromdir/' '$chkdir/'" "$fromdir" "$chkdir"
+
+# Create a hard link that has only one part in the hierarchy.
+echo "This is another file" >"$fromdir/solo"
+ln "$fromdir/solo" "$chkdir/solo" || test_fail "Can't create hardlink"
+
+# Make sure that the checksum data doesn't slide due to an HLINK_BUMP() change.
+checktee "$RSYNC -aHivc --debug=HLINK5 '$fromdir/' '$chkdir/'"
+grep solo "$outfile" && test_fail "Erroneous copy of solo file occurred!"
+
+# Make sure there's nothing wrong with sending a single file with -H
+# enabled (this has broken twice so far, so we need this test).
+rm -rf "$todir"
+$RSYNC -aHivv --debug=HLINK5 "$name1" "$todir/"
+diff $diffopt "$name1" "$todir" || test_fail "solo copy of name1 failed"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/itemize.test b/testsuite/itemize.test
new file mode 100644
index 0000000..c1c57c5
--- /dev/null
+++ b/testsuite/itemize.test
@@ -0,0 +1,246 @@
+#!/bin/sh
+
+# Copyright (C) 2005-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test the output of various copy commands to ensure itemized output
+# and double-verbose output is correct.
+
+. "$suitedir/rsync.fns"
+
+to2dir="$tmpdir/to2"
+
+makepath "$fromdir/foo"
+makepath "$fromdir/bar/baz"
+cp_p "$srcdir/configure.ac" "$fromdir/foo/config1"
+cp_p "$srcdir/config.sub" "$fromdir/foo/config2"
+cp_p "$srcdir/rsync.h" "$fromdir/bar/baz/rsync"
+chmod 600 "$fromdir"/foo/config? "$fromdir/bar/baz/rsync"
+umask 0
+ln -s ../bar/baz/rsync "$fromdir/foo/sym"
+umask 022
+ln "$fromdir/foo/config1" "$fromdir/foo/extra"
+rm -f "$to2dir"
+
+# Check if rsync is set to hard-link symlinks.
+if $RSYNC -VV | grep '"hardlink_symlinks": true' >/dev/null; then
+    L=hL
+    sym_dots="$allspace"
+    L_sym_dots=".L$allspace"
+    is_uptodate='is uptodate'
+    touch "$chkfile.extra"
+else
+    L=cL
+    sym_dots="c.t.$dots"
+    L_sym_dots="cL$sym_dots"
+    is_uptodate='-> ../bar/baz/rsync'
+    echo "cL$sym_dots foo/sym $is_uptodate" >"$chkfile.extra"
+fi
+
+# Check if rsync can preserve time on symlinks
+case "$RSYNC" in
+*protocol=2*)
+    T=.T
+    ;;
+*)
+    if $RSYNC -VV | grep '"symtimes": true' >/dev/null; then
+	T=.t
+    else
+	T=.T
+    fi
+    ;;
+esac
+
+checkdiff "$RSYNC -iplr '$fromdir/' '$todir/'" <<EOT
+created directory $todir
+cd$all_plus ./
+cd$all_plus bar/
+cd$all_plus bar/baz/
+>f$all_plus bar/baz/rsync
+cd$all_plus foo/
+>f$all_plus foo/config1
+>f$all_plus foo/config2
+>f$all_plus foo/extra
+cL$all_plus foo/sym -> ../bar/baz/rsync
+EOT
+
+# Ensure there are no accidental directory-time problems.
+$RSYNC -a -f '-! */' "$fromdir/" "$todir"
+
+cp_p "$srcdir/configure.ac" "$fromdir/foo/config2"
+chmod 601 "$fromdir/foo/config2"
+checkdiff "$RSYNC -iplrH '$fromdir/' '$todir/'" <<EOT
+>f..T.$dots bar/baz/rsync
+>f..T.$dots foo/config1
+>f.sTp$dots foo/config2
+hf..T.$dots foo/extra => foo/config1
+EOT
+
+$RSYNC -a -f '-! */' "$fromdir/" "$todir"
+cp_p "$srcdir/config.sub" "$fromdir/foo/config2"
+sleep 1 # For directory mod below to ensure time difference
+rm "$todir/foo/sym"
+umask 0
+ln -s ../bar/baz "$todir/foo/sym"
+umask 022
+chmod 600 "$fromdir/foo/config2"
+chmod 777 "$todir/bar/baz/rsync"
+
+checkdiff "$RSYNC -iplrtc '$fromdir/' '$todir/'" <<EOT
+.f..tp$dots bar/baz/rsync
+.d..t.$dots foo/
+.f..t.$dots foo/config1
+>fcstp$dots foo/config2
+cLc$T.$dots foo/sym -> ../bar/baz/rsync
+EOT
+
+cp_p "$srcdir/configure.ac" "$fromdir/foo/config2"
+chmod 600 "$fromdir/foo/config2"
+# Lack of -t is for unchanged hard-link stress-test!
+checkdiff "$RSYNC -vvplrH '$fromdir/' '$todir/'" \
+	v_filt <<EOT
+bar/baz/rsync is uptodate
+foo/config1 is uptodate
+foo/extra is uptodate
+foo/sym is uptodate
+foo/config2
+EOT
+
+chmod 747 "$todir/bar/baz/rsync"
+$RSYNC -a -f '-! */' "$fromdir/" "$todir"
+checkdiff "$RSYNC -ivvplrtH '$fromdir/' '$todir/'" \
+	v_filt <<EOT
+.d$allspace ./
+.d$allspace bar/
+.d$allspace bar/baz/
+.f...p$dots bar/baz/rsync
+.d$allspace foo/
+.f$allspace foo/config1
+>f..t.$dots foo/config2
+hf$allspace foo/extra
+.L$allspace foo/sym -> ../bar/baz/rsync
+EOT
+
+chmod 757 "$todir/foo/config1"
+touch "$todir/foo/config2"
+checkdiff "$RSYNC -vplrtH '$fromdir/' '$todir/'" \
+	v_filt <<EOT
+foo/config2
+EOT
+
+chmod 757 "$todir/foo/config1"
+touch "$todir/foo/config2"
+checkdiff "$RSYNC -iplrtH '$fromdir/' '$todir/'" <<EOT
+.f...p$dots foo/config1
+>f..t.$dots foo/config2
+EOT
+
+checkdiff "$RSYNC -ivvplrtH --copy-dest=../to '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+cd$allspace ./
+cd$allspace bar/
+cd$allspace bar/baz/
+cf$allspace bar/baz/rsync
+cd$allspace foo/
+cf$allspace foo/config1
+cf$allspace foo/config2
+hf$allspace foo/extra => foo/config1
+cL$sym_dots foo/sym -> ../bar/baz/rsync
+EOT
+
+rm -rf "$to2dir"
+cat - "$chkfile.extra" <<EOT >"$chkfile"
+created directory $to2dir
+hf$allspace foo/extra => foo/config1
+EOT
+checkdiff2 "$RSYNC -iplrtH --copy-dest=../to '$fromdir/' '$to2dir/'"
+
+rm -rf "$to2dir"
+checkdiff "$RSYNC -vvplrtH --copy-dest='$todir' '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+./ is uptodate
+bar/ is uptodate
+bar/baz/ is uptodate
+bar/baz/rsync is uptodate
+foo/ is uptodate
+foo/config1 is uptodate
+foo/config2 is uptodate
+foo/sym $is_uptodate
+foo/extra => foo/config1
+EOT
+
+rm -rf "$to2dir"
+checkdiff "$RSYNC -ivvplrtH --link-dest='$todir' '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+cd$allspace ./
+cd$allspace bar/
+cd$allspace bar/baz/
+hf$allspace bar/baz/rsync
+cd$allspace foo/
+hf$allspace foo/config1
+hf$allspace foo/config2
+hf$allspace foo/extra => foo/config1
+$L$sym_dots foo/sym -> ../bar/baz/rsync
+EOT
+
+rm -rf "$to2dir"
+cat - "$chkfile.extra" <<EOT >"$chkfile"
+created directory $to2dir
+EOT
+checkdiff2 "$RSYNC -iplrtH --dry-run --link-dest=../to '$fromdir/' '$to2dir/'"
+
+rm -rf "$to2dir"
+checkdiff2 "$RSYNC -iplrtH --link-dest=../to '$fromdir/' '$to2dir/'"
+
+rm -rf "$to2dir"
+checkdiff "$RSYNC -vvplrtH --link-dest='$todir' '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+./ is uptodate
+bar/ is uptodate
+bar/baz/ is uptodate
+bar/baz/rsync is uptodate
+foo/ is uptodate
+foo/config1 is uptodate
+foo/config2 is uptodate
+foo/extra is uptodate
+foo/sym $is_uptodate
+EOT
+
+rm -rf "$to2dir"
+checkdiff "$RSYNC -ivvplrtH --compare-dest='$todir' '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+cd$allspace ./
+cd$allspace bar/
+cd$allspace bar/baz/
+.f$allspace bar/baz/rsync
+cd$allspace foo/
+.f$allspace foo/config1
+.f$allspace foo/config2
+.f$allspace foo/extra
+$L_sym_dots foo/sym -> ../bar/baz/rsync
+EOT
+
+rm -rf "$to2dir"
+cat - "$chkfile.extra" <<EOT >"$chkfile"
+created directory $to2dir
+EOT
+checkdiff2 "$RSYNC -iplrtH --compare-dest='$todir' '$fromdir/' '$to2dir/'"
+
+rm -rf "$to2dir"
+checkdiff "$RSYNC -vvplrtH --compare-dest='$todir' '$fromdir/' '$to2dir/'" \
+	v_filt <<EOT
+./ is uptodate
+bar/ is uptodate
+bar/baz/ is uptodate
+bar/baz/rsync is uptodate
+foo/ is uptodate
+foo/config1 is uptodate
+foo/config2 is uptodate
+foo/extra is uptodate
+foo/sym $is_uptodate
+EOT
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/longdir.test b/testsuite/longdir.test
new file mode 100644
index 0000000..8d66bb5
--- /dev/null
+++ b/testsuite/longdir.test
@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Copyright (C) 1998,1999 Philip Hands <phil@hands.com>
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+#
+# This program is distributable under the terms of the GNU GPL (see COPYING)
+
+. "$suitedir/rsync.fns"
+
+hands_setup
+
+longname=This-is-a-directory-with-a-stupidly-long-name-created-in-an-attempt-to-provoke-an-error-found-in-2.0.11-that-should-hopefully-never-appear-again-if-this-test-does-its-job
+longdir="$fromdir/$longname/$longname/$longname"
+
+makepath "$longdir" || test_skipped "unable to create long directory"
+touch "$longdir/1" || test_skipped "unable to create files in long directory"
+date > "$longdir/1"
+if [ -r /etc ]; then
+    ls -la /etc >"$longdir/2"
+else
+    ls -la / >"$longdir/2"
+fi
+checkit "$RSYNC --delete -avH '$fromdir/' '$todir'" "$fromdir/" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/merge.test b/testsuite/merge.test
new file mode 100644
index 0000000..17050a1
--- /dev/null
+++ b/testsuite/merge.test
@@ -0,0 +1,57 @@
+#!/bin/sh
+
+# Copyright (C) 2004-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Make sure we can merge files from multiple directories into one.
+
+. "$suitedir/rsync.fns"
+
+# Build some files/dirs/links to copy
+
+# Use local dirnames to better exercise the arg-parsing code.
+cd "$tmpdir"
+
+mkdir from1 from2 from3 deep
+mkdir from2/sub1 from3/sub1
+mkdir from3/sub2 from1/dir-and-not-dir
+mkdir chk chk/sub1 chk/sub2 chk/dir-and-not-dir
+echo "one" >from1/one
+cp_touch from1/one from2/one
+cp_touch from1/one from3/one
+echo "two" >from1/two
+echo "three" >from2/three
+echo "four" >from3/four
+echo "five" >from1/five
+echo "six" >from3/six
+echo "sub1" >from2/sub1/uno
+cp_touch from2/sub1/uno from3/sub1/uno
+echo "sub2" >from3/sub1/dos
+echo "sub3" >from2/sub1/tres
+echo "subby" >from3/sub2/subby
+echo "extra" >from1/dir-and-not-dir/inside
+echo "not-dir" >from3/dir-and-not-dir
+echo "arg-test" >deep/arg-test
+echo "shallow" >shallow
+
+cp_touch from1/one from1/two from2/three from3/four from1/five from3/six chk
+cp_touch deep/arg-test shallow chk
+cp_touch from1/dir-and-not-dir/inside chk/dir-and-not-dir
+cp_touch from2/sub1/uno from3/sub1/dos from2/sub1/tres chk/sub1
+cp_touch from3/sub2/subby chk/sub2
+
+# Make sure that time has moved on.
+sleep 1
+
+# Get rid of any directory-time differences
+$RSYNC -av --existing -f 'exclude,! */' from1/ from2/
+$RSYNC -av --existing -f 'exclude,! */' from2/ from3/
+$RSYNC -av --existing -f 'exclude,! */' from1/ chk/
+$RSYNC -av --existing -f 'exclude,! */' from3/ chk/
+
+checkit "$RSYNC -avv deep/arg-test shallow from1/ from2/ from3/ to/" "$chkdir" "$todir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/missing.test b/testsuite/missing.test
new file mode 100644
index 0000000..2fbf461
--- /dev/null
+++ b/testsuite/missing.test
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test three bugs fixed by my redoing of the missing_below logic.
+
+. $suitedir/rsync.fns
+
+makepath "$fromdir/subdir" "$todir"
+echo data >"$fromdir/subdir/file"
+echo data >"$todir/other"
+
+# Test 1: Too much "not creating new..." output on a dry run
+$RSYNC -n -r --ignore-non-existing -vv "$fromdir/" "$todir/" | tee "$scratchdir/out"
+if grep 'not creating new.*subdir/file' "$scratchdir/out" >/dev/null; then
+	test_fail 'test 1 failed'
+fi
+
+case "$RSYNC" in
+*protocol=29*) # FIXME can we get past the new flist sanity check in protocol 29?
+	echo "Skipped test 2 for protocol 29."
+	;;
+*)
+	# Test 2: Attempt to make a fuzzy dirlist for a dir not created on a dry run
+	$RSYNC -n -r -R --no-implied-dirs -y "$fromdir/./subdir/file" "$todir/" \
+		|| test_fail 'test 2 failed'
+	;;
+esac
+
+# Test 3: --delete-after pass skipped when last dir is dry-missing
+$RSYNC -n -r --delete-after -i "$fromdir/" "$todir/" | tee "$scratchdir/out"
+grep '^\*deleting * other' "$scratchdir/out" >/dev/null \
+	|| test_fail 'test 3 failed'
diff --git a/testsuite/mkpath.test b/testsuite/mkpath.test
new file mode 100644
index 0000000..8046345
--- /dev/null
+++ b/testsuite/mkpath.test
@@ -0,0 +1,47 @@
+#!/bin/sh
+
+. "$suitedir/rsync.fns"
+
+makepath "$fromdir"
+makepath "$todir"
+
+cp_p "$srcdir/rsync.h" "$fromdir/text"
+cp_p "$srcdir/configure.ac" "$fromdir/extra"
+
+cd "$tmpdir"
+
+deep_dir=to/foo/bar/baz/down/deep
+
+# Check that we can create several levels of dest dir
+$RSYNC -aiv --mkpath from/text $deep_dir/new
+test -f $deep_dir/new || test_fail "'new' file not found in $deep_dir dir"
+rm -rf to/foo
+
+$RSYNC -aiv --mkpath from/text $deep_dir/
+test -f $deep_dir/text || test_fail "'text' file not found in $deep_dir dir"
+rm $deep_dir/text
+
+# Make sure we can handle an existing path
+mkdir $deep_dir/new
+$RSYNC -aiv --mkpath from/text $deep_dir/new
+test -f $deep_dir/new/text || test_fail "'text' file not found in $deep_dir/new dir"
+
+# ... and an existing path when an alternate dest filename is specified
+$RSYNC -aiv --mkpath from/text $deep_dir/new/text2
+test -f $deep_dir/new/text2 || test_fail "'text2' file not found in $deep_dir/new dir"
+rm -rf to/foo
+
+# Try the tests again with multiple source args
+$RSYNC -aiv --mkpath from/ $deep_dir
+test -f $deep_dir/extra || test_fail "'extra' file not found in $deep_dir dir"
+rm -rf to/foo
+
+$RSYNC -aiv --mkpath from/ $deep_dir/
+test -f $deep_dir/text || test_fail "'text' file not found in $deep_dir dir"
+
+# Make sure that we can handle no path
+$RSYNC -aiv --mkpath from/text to_text
+test -f to_text || test_fail "'to_text' file not found in current dir"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/protected-regular.test b/testsuite/protected-regular.test
new file mode 100644
index 0000000..40416b0
--- /dev/null
+++ b/testsuite/protected-regular.test
@@ -0,0 +1,31 @@
+#!/bin/sh
+
+# Copyright (C) 2021 by Achim Leitner <aleitner@lis-engineering.de>
+# This program is distributable under the terms of the GNU GPL (see COPYING)
+#
+# Modern linux systems have the protected_regular feature set to 1 or 2
+# See https://www.kernel.org/doc/Documentation/sysctl/fs.txt
+# Make sure we can still write these files in --inplace mode
+
+. "$suitedir/rsync.fns"
+
+test -f /proc/sys/fs/protected_regular || test_skipped "Can't find protected_regular setting (only available on Linux)"
+pr_lvl=`cat /proc/sys/fs/protected_regular 2>/dev/null` || test_skipped "Can't check if fs.protected_regular is enabled (probably need root)"
+test "$pr_lvl" != 0 || test_skipped "fs.protected_regular is not enabled"
+
+workdir="$tmpdir/files"
+mkdir "$workdir"
+chmod 1777 "$workdir"
+
+echo "Source" > "$workdir/src"
+echo ""       > "$workdir/dst"
+chown 5001 "$workdir/dst" || test_skipped "Can't chown (probably need root)"
+
+# Output is only shown in case of an error
+echo "Contents of $workdir:"
+ls -al "$workdir"
+
+$RSYNC --inplace "$workdir/src" "$workdir/dst" || test_fail
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/relative.test b/testsuite/relative.test
new file mode 100644
index 0000000..5546291
--- /dev/null
+++ b/testsuite/relative.test
@@ -0,0 +1,60 @@
+#!/bin/sh
+
+# Copyright (C) 2005-2020 Wayne Davison
+#
+# This program is distributable under the terms of the GNU GPL (see COPYING)
+
+. "$suitedir/rsync.fns"
+
+deepstr='down/3/deep'
+deepdir="$fromdir/$deepstr"
+extradir="$fromdir/extra"
+makepath "$deepdir" "$extradir/$deepstr" "$chkdir"
+
+fromdir="$deepdir"
+hands_setup
+fromdir="$tmpdir/from"
+
+extrafile="$extradir/./$deepstr/extra.added.value"
+echo wowza >"$extrafile"
+
+$RSYNC -av --existing --include='*/' --exclude='*' "$fromdir/" "$extradir/"
+
+cd "$fromdir"
+
+# Main script starts here
+
+$RSYNC -ai --include=/down/ --exclude='/*' "$fromdir/" "$chkdir/"
+
+sleep 1
+runtest "basic relative" 'checkit "$RSYNC -avR ./$deepstr \"$todir\"" "$chkdir" "$todir"'
+
+ln $deepstr/filelist $deepstr/dir
+ln ../chk/$deepstr/filelist ../chk/$deepstr/dir
+# Work around time rounding/truncating issue by touching both dirs.
+touch -r $deepstr/dir $deepstr/dir ../chk/$deepstr/dir
+runtest "hard links" 'checkit "$RSYNC -avHR ./$deepstr/ \"$todir\"" "$chkdir" "$todir"'
+
+cp "$deepdir/text" "$todir/$deepstr/ThisShouldGo"
+cp "$deepdir/text" "$todir/$deepstr/dir/ThisShouldGoToo"
+runtest "deletion" 'checkit "$RSYNC -avHR --del ./$deepstr/ \"$todir\"" "$chkdir" "$todir"'
+
+runtest "non-deletion" 'checkit "$RSYNC -aiHR --del ./$deepstr/ \"$todir\"" "$chkdir" "$todir"' \
+    | tee "$outfile"
+
+# Make sure no files were deleted
+grep 'deleting ' "$outfile" && test_fail "Erroneous deletions occurred!"
+
+# Relative with merging.
+$RSYNC -ai "$extradir/down" "$chkdir/"
+
+checkit "$RSYNC -aiR $deepstr '$extrafile' '$todir'" "$chkdir" "$todir"
+
+checkit "$RSYNC -aiR --del $deepstr '$extrafile' '$todir'" "$chkdir" "$todir" \
+    | tee "$outfile"
+
+# Make sure no files were deleted
+grep 'deleting ' "$outfile" && test_fail "Erroneous deletions occurred! (2)"
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/rsync.fns b/testsuite/rsync.fns
new file mode 100644
index 0000000..2ab97b6
--- /dev/null
+++ b/testsuite/rsync.fns
@@ -0,0 +1,498 @@
+#!/bin/sh
+
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+# General-purpose test functions for rsync.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version
+# 2 as published by the Free Software Foundation.
+#
+# 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+tmpdir="$scratchdir"
+fromdir="$tmpdir/from"
+todir="$tmpdir/to"
+chkdir="$tmpdir/chk"
+
+chkfile="$scratchdir/rsync.chk"
+outfile="$scratchdir/rsync.out"
+
+# For itemized output:
+all_plus='+++++++++'
+allspace='         '
+dots='.....' # trailing dots after changes
+tab_ch='	' # a single tab character
+
+# Berkley's nice.
+PATH="$PATH:/usr/ucb"
+
+if diff -u "$suitedir/rsync.fns" "$suitedir/rsync.fns" >/dev/null 2>&1; then
+    diffopt="-u"
+else
+    diffopt="-c"
+fi
+
+HOME="$scratchdir"
+export HOME
+
+runtest() {
+    echo $ECHO_N "Test $1: $ECHO_C"
+    if eval "$2"; then
+        echo "$ECHO_T	done."
+        return 0
+    else
+        echo "$ECHO_T failed!"
+        return 1
+    fi
+}
+
+set_cp_destdir() {
+    while test $# -gt 1; do
+	shift
+    done
+    destdir="$1"
+}
+
+# Perform a "cp -p", making sure that timestamps are really the same,
+# even if the copy rounded microsecond times on the destination file.
+cp_touch() {
+    cp_p "${@}"
+    if test $# -gt 2 || test -d "$2"; then
+	set_cp_destdir "${@}" # sets destdir var
+	while test $# -gt 1; do
+	    destname="$destdir/`basename $1`"
+	    touch -r "$destname" "$1" "$destname"
+	    shift
+	done
+    else
+	touch -r "$2" "$1" "$2"
+    fi
+}
+
+# Call this if you want to filter (stdin -> stdout) verbose messages (-v or
+# -vv) from an rsync run (whittling the output down to just the file messages).
+# This isn't needed if you use -i without -v.
+v_filt() {
+    sed -e '/^building file list /d' \
+	-e '/^sending incremental file list/d' \
+	-e '/^created directory /d' \
+	-e '/^done$/d' \
+	-e '/ --whole-file$/d' \
+	-e '/^total: /d' \
+	-e '/^client charset: /d' \
+	-e '/^server charset: /d' \
+	-e '/^$/,$d'
+}
+
+printmsg() {
+    echo "$1"
+}
+
+rsync_ls_lR() {
+    find "$@" -name .git -prune -o -name auto-build-save -prune -o -print | \
+	sort | sed 's/ /\\ /g' | xargs "$TOOLDIR/tls" $TLS_ARGS
+}
+
+get_testuid() {
+    uid=`id -u 2>/dev/null || true`
+    case "$uid" in
+	[0-9]*) echo "$uid" ;;
+	*) id 2>/dev/null | sed 's/^[^0-9]*\([0-9][0-9]*\).*/\1/' ;;
+    esac
+}
+
+get_rootuid() {
+    uid=`id -u root 2>/dev/null || true`
+    case "$uid" in
+	[0-9]*) echo "$uid" ;;
+	*) echo 0 ;;
+    esac
+}
+
+get_rootgid() {
+    gid=`id -g root 2>/dev/null || true`
+    case "$gid" in
+	[0-9]*) echo "$gid" ;;
+	*) echo 0 ;;
+    esac
+}
+
+# When copying via "cp -p", we want to ensure that a non-root user does not
+# preserve ownership (we want our files to be created as the testing user).
+# For instance, a Cygwin CI run might have git files owned by a different
+# user than the (admin) user running the tests.
+cp_cmd="cp -p"
+if test x`get_testuid` != x0; then
+    case `cp --help 2>/dev/null` in
+	*--no-preserve=*) cp_cmd="cp -p --no-preserve=ownership" ;;
+    esac
+fi
+cp_p() {
+    $cp_cmd "${@}" || test_fail "$cp_cmd failed"
+}
+
+check_perms() {
+    perms=`"$TOOLDIR/tls" "$1" | sed 's/^[-d]\(.........\).*/\1/'`
+    if test $perms = $2; then
+	return 0
+    fi
+    echo "permissions: $perms on $1"
+    echo "should be:   $2"
+    test_fail "failed test $3"
+}
+
+rsync_getgroups() {
+    "$TOOLDIR/getgroups"
+}
+
+
+####################
+# Build test directories $todir and $fromdir, with $fromdir full of files.
+
+hands_setup() {
+    # Clean before creation
+    rm -rf "$fromdir"
+    rm -rf "$todir"
+
+    [ -d "$tmpdir" ] || mkdir "$tmpdir"
+    [ -d "$fromdir" ] || mkdir "$fromdir"
+    [ -d "$todir" ] || mkdir "$todir"
+
+    # On some BSD systems, the umask affects the mode of created
+    # symlinks, even though the mode apparently has no effect on how
+    # the links behave in the future, and it cannot be changed using
+    # chmod!  rsync always sets its umask to 000 so that it can
+    # accurately recreate permissions, but this script is probably run
+    # with a different umask.
+
+    # This causes a little problem that "ls -l" of the two will not be
+    # the same.  So, we need to set our umask before doing any creations.
+
+    # set up test data
+    touch "$fromdir/empty"
+    mkdir "$fromdir/emptydir"
+
+    # a hundred lines of text or so
+    rsync_ls_lR "$srcdir" > "$fromdir/filelist"
+
+    echo $ECHO_N "This file has no trailing lf$ECHO_C" > "$fromdir/nolf"
+    umask 0
+    ln -s nolf "$fromdir/nolf-symlink"
+    umask 022
+
+    cat "$srcdir"/*.c > "$fromdir/text"
+    mkdir "$fromdir/dir"
+    cp "$fromdir/text" "$fromdir/dir"
+    mkdir "$fromdir/dir/subdir"
+    echo some data > "$fromdir/dir/subdir/foobar.baz"
+    mkdir "$fromdir/dir/subdir/subsubdir"
+    if [ -r /etc ]; then
+	ls -ltr /etc > "$fromdir/dir/subdir/subsubdir/etc-ltr-list"
+    else
+	ls -ltr / > "$fromdir/dir/subdir/subsubdir/etc-ltr-list"
+    fi
+    mkdir "$fromdir/dir/subdir/subsubdir2"
+    if [ -r /bin ]; then
+	ls -lt /bin > "$fromdir/dir/subdir/subsubdir2/bin-lt-list"
+    else
+	ls -lt / > "$fromdir/dir/subdir/subsubdir2/bin-lt-list"
+    fi
+
+#      echo testing head:
+#      ls -lR "$srcdir" | head -10 || echo failed
+}
+
+
+####################
+# Many machines do not have "mkdir -p", so we have to build up long paths.
+# How boring.
+makepath() {
+    for p in "${@}"; do
+	(echo "        makepath $p"
+
+	# Absolute Unix path.
+	if echo $p | grep '^/' >/dev/null; then
+	    cd /
+	fi
+
+	# This will break if $p contains a space.
+	for c in `echo $p | tr '/' ' '`; do
+	    if [ -d "$c" ] || mkdir "$c"; then
+		cd "$c" || return $?
+	    else
+		echo "failed to create $c" >&2; return $?
+	    fi
+	done)
+    done
+}
+
+
+###########################
+# Run a test (in '$1') then compare directories $2 and $3 to see if
+# there are any difference.  If there are, explain them.
+
+# So normally basically $1 should be an rsync command, and $2 and $3
+# the source and destination directories.  This is only good when you
+# expect to transfer the whole directory exactly as is.  If some files
+# should be excluded, you might need to use something else.
+
+checkit() {
+    failed=
+
+    # We can just write everything to stdout/stderr, because the
+    # wrapper hides it unless there is a problem.
+
+    case "x$TLS_ARGS" in
+    *--atimes*)
+	( cd "$2" && rsync_ls_lR . ) > "$tmpdir/ls-from"
+	;;
+    *)
+	;;
+    esac
+
+    echo "Running: \"$1\""
+    eval "$1"
+    status=$?
+    if [ $status != 0 ]; then
+	failed="$failed status=$status"
+    fi
+
+    case "x$TLS_ARGS" in
+    *--atimes*)
+	;;
+    *)
+	( cd "$2" && rsync_ls_lR . ) > "$tmpdir/ls-from"
+	;;
+    esac
+
+    echo "-------------"
+    echo "check how the directory listings compare with diff:"
+    echo ""
+    ( cd "$3" && rsync_ls_lR . ) > "$tmpdir/ls-to"
+    diff $diffopt "$tmpdir/ls-from" "$tmpdir/ls-to" || failed="$failed dir-diff"
+
+    echo "-------------"
+    echo "check how the files compare with diff:"
+    echo ""
+    if [ "x$4" != x ]; then
+	echo "  === Skipping (as directed) ==="
+    else
+	diff -r $diffopt "$2" "$3" || failed="$failed file-diff"
+    fi
+
+    echo "-------------"
+    if [ -z "$failed" ]; then
+	return 0
+    fi
+
+    echo "Failed: $failed"
+    return 1
+}
+
+
+# Run a test in $1 and make sure it has a zero exit status.  Capture the
+# output into $outfile and echo it to stdout.
+checktee() {
+    echo "Running: \"$1\""
+    eval "$1" >"$outfile"
+    status=$?
+    cat "$outfile"
+    if [ $status != 0 ]; then
+	echo "Failed: status=$status"
+	return 1
+    fi
+    return 0
+}
+
+
+# Slurp stdin into $chkfile and then call checkdiff2().
+checkdiff() {
+    cat >"$chkfile" # Save off stdin
+    checkdiff2 "${@}"
+}
+
+
+# Run a test in $1 and make sure it has a zero exit status.  Capture the output
+# into $outfile.  If $2 is set, use it to filter the outfile.  If resulting
+# outfile differs from the chkfile data, fail with an error.
+checkdiff2() {
+    failed=
+
+    echo "Running: \"$1\""
+    eval "$1" >"$outfile"
+    status=$?
+    cat "$outfile"
+    if [ $status != 0 ]; then
+	failed="$failed status=$status"
+    fi
+
+    if [ -n "$2" ]; then
+	eval "cat '$outfile' | $2 >'$outfile.new'"
+	mv "$outfile.new" "$outfile"
+    fi
+
+    diff $diffopt "$chkfile" "$outfile" || failed="$failed output differs"
+
+    if [ -n "$failed" ]; then
+	echo "Failed:$failed"
+	return 1
+    fi
+    return 0
+}
+
+
+build_rsyncd_conf() {
+    # Build an appropriate configuration file
+    conf="$scratchdir/test-rsyncd.conf"
+    echo "building configuration $conf"
+
+    port=2612
+    pidfile="$scratchdir/rsyncd.pid"
+    logfile="$scratchdir/rsyncd.log"
+    hostname=`uname -n`
+
+    my_uid=`get_testuid`
+    root_uid=`get_rootuid`
+    root_gid=`get_rootgid`
+
+    uid_setting="uid = $root_uid"
+    gid_setting="gid = $root_gid"
+
+    if test x"$my_uid" != x"$root_uid"; then
+	# Non-root cannot specify uid & gid settings
+	uid_setting="#$uid_setting"
+	gid_setting="#$gid_setting"
+    fi
+
+    cat >"$conf" <<EOF
+# rsyncd configuration file autogenerated by $0
+
+pid file = $pidfile
+use chroot = no
+munge symlinks = no
+hosts allow = localhost 127.0.0.0/24 192.168.0.0/16 10.0.0.0/8 $hostname
+log file = $logfile
+transfer logging = yes
+# We don't define log format here so that the test-hidden module will default
+# to the internal static string (since we had a crash trying to tweak it).
+exclude = ? foobar.baz
+max verbosity = 4
+$uid_setting
+$gid_setting
+
+[test-from]
+	path = $fromdir
+	log format = %i %h [%a] %m (%u) %l %f%L
+	read only = yes
+	comment = r/o
+
+[test-to]
+	path = $todir
+	log format = %i %h [%a] %m (%u) %l %f%L
+	read only = no
+	comment = r/w
+
+[test-scratch]
+	path = $scratchdir
+	log format = %i %h [%a] %m (%u) %l %f%L
+	read only = no
+
+[test-hidden]
+	path = $fromdir
+	list = no
+EOF
+
+    # Build a helper script to ignore exit code 23
+    ignore23="$scratchdir/ignore23"
+    echo "building help script $ignore23"
+
+    cat >"$ignore23" <<'EOT'
+if "${@}"; then
+    exit
+fi
+
+ret=$?
+
+if test $ret = 23; then
+    exit
+fi
+
+exit $ret
+EOT
+chmod +x "$ignore23"
+}
+
+
+build_symlinks() {
+    mkdir "$fromdir"
+    date >"$fromdir/referent"
+    ln -s referent "$fromdir/relative"
+    ln -s "$fromdir/referent" "$fromdir/absolute"
+    ln -s nonexistent "$fromdir/dangling"
+    ln -s "$srcdir/rsync.c" "$fromdir/unsafe"
+}
+
+test_fail() {
+    echo "$@" >&2
+    exit 1
+}
+
+test_skipped() {
+    echo "$@" >&2
+    echo "$@" > "$tmpdir/whyskipped"
+    exit 77
+}
+
+# It failed, but we expected that.  Don't dump out error logs,
+# because most users won't want to see them.  But do leave
+# the working directory around.
+test_xfail() {
+    echo "$@" >&2
+    exit 78
+}
+
+# Determine what shell command will appropriately test for links.
+ln -s foo "$scratchdir/testlink"
+for cmd in test /bin/test /usr/bin/test /usr/ucb/bin/test /usr/ucb/test; do
+    for switch in -h -L; do
+        if $cmd $switch "$scratchdir/testlink" 2>/dev/null; then
+            # how nice
+            TEST_SYMLINK_CMD="$cmd $switch"
+            # i wonder if break 2 is portable?
+            break 2
+        fi
+    done
+done
+# ok, now get rid of it
+rm "$scratchdir/testlink"
+
+
+if [ "x$TEST_SYMLINK_CMD" = 'x' ]; then
+    test_fail "Couldn't determine how to test for symlinks"
+else
+    echo "Testing for symlinks using '$TEST_SYMLINK_CMD'"
+fi
+
+
+# Test whether something is a link, allowing for shell peculiarities
+is_a_link() {
+    # note the variable contains the first option and therefore is not quoted
+    $TEST_SYMLINK_CMD "$1"
+}
+
+
+# We need to set the umask to be reproducible.  Note also that when we
+# do some daemon tests as root, we will setuid() and therefore the
+# directory has to be writable by the nobody user in some cases.  The
+# best thing is probably to explicitly chmod those directories after
+# creation.
+
+umask 022
diff --git a/testsuite/ssh-basic.test b/testsuite/ssh-basic.test
new file mode 100644
index 0000000..1559ca2
--- /dev/null
+++ b/testsuite/ssh-basic.test
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+# Copyright (C) 1998,1999 Philip Hands <phil@hands.com>
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING)
+
+# This script tests ssh, if possible.  It's called by runtests.sh
+
+. "$suitedir/rsync.fns"
+
+SSH="$scratchdir/src/support/lsh.sh"
+
+if test x"$rsync_enable_ssh_tests" = xyes; then
+    if type ssh >/dev/null; then
+	SSH=ssh
+    fi
+fi
+
+if [ "`$SSH -o'BatchMode yes' localhost echo yes`" != "yes" ]; then
+    test_skipped "Skipping SSH tests because ssh connection to localhost not authorised"
+fi
+
+echo "Using remote shell: $SSH"
+
+# Create some files for rsync to copy
+hands_setup
+
+runtest "ssh: basic test" 'checkit "$RSYNC -avH -e \"$SSH\" --rsync-path=\"$RSYNC\" \"$fromdir/\" \"localhost:$todir\"" "$fromdir/" "$todir"'
+
+mv "$todir/text" "$todir/ThisShouldGo"
+
+runtest "ssh: renamed file" 'checkit "$RSYNC --delete -avH -e \"$SSH\" --rsync-path=\"$RSYNC\" \"$fromdir/\" \"localhost:$todir\"" "$fromdir/" "$todir"'
diff --git a/testsuite/symlink-ignore.test b/testsuite/symlink-ignore.test
new file mode 100644
index 0000000..7055a92
--- /dev/null
+++ b/testsuite/symlink-ignore.test
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+# Copyright (C) 2001 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test rsync's somewhat over-featured symlink control: the default
+# behaviour is that symlinks should not be copied at all.
+
+. "$suitedir/rsync.fns"
+
+build_symlinks || test_fail "failed to build symlinks"
+
+# Copy recursively, but without -l or -L or -a, and all the symlinks
+# should be missing.
+$RSYNC -r "$fromdir/" "$todir" || test_fail "$RSYNC returned $?"
+
+[ -f "$todir/referent" ] || test_fail "referent was not copied"
+[ -d "$todir/from" ] && test_fail "extra level of directories"
+if is_a_link "$todir/dangling"; then
+    test_fail "dangling symlink was copied"
+fi
+
+if is_a_link "$todir/relative"; then
+    test_fail "relative symlink was copied"
+fi
+
+if is_a_link "$todir/absolute"; then
+    test_fail "absolute symlink was copied"
+fi
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/trimslash.test b/testsuite/trimslash.test
new file mode 100644
index 0000000..2efaa07
--- /dev/null
+++ b/testsuite/trimslash.test
@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool <mbp@samba.org>
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test tiny function to trim trailing slashes.
+
+. "$suitedir/rsync.fns"
+
+"$TOOLDIR/trimslash" "/usr/local/bin" "/usr/local/bin/" "/usr/local/bin///" \
+	"//a//" "////" \
+        "/Users/Weird Macintosh Name/// Ooh, translucent plastic/" \
+	> "$scratchdir/slash.out"
+diff $diffopt "$scratchdir/slash.out" - <<EOF
+/usr/local/bin
+/usr/local/bin
+/usr/local/bin
+//a
+/
+/Users/Weird Macintosh Name/// Ooh, translucent plastic
+EOF
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/unsafe-byname.test b/testsuite/unsafe-byname.test
new file mode 100644
index 0000000..75e7201
--- /dev/null
+++ b/testsuite/unsafe-byname.test
@@ -0,0 +1,58 @@
+#!/bin/sh
+
+# Copyright (C) 2002 by Martin Pool
+
+# Call directly into unsafe_symlink and test its handling of various filenames
+
+. "$suitedir/rsync.fns"
+
+test_unsafe() {
+    # $1 is the target of a symlink
+    # $2 is the directory we're copying
+    # $3 is the expected outcome: "safe" if the link lies within $2,
+    # or "unsafe" otherwise
+
+    result=`"$TOOLDIR/t_unsafe" "$1" "$2"` || test_fail "Failed to check $1 $2"
+    if [ "$result" != "$3" ]; then
+        test_fail "t_unsafe $1 $2 returned \"$result\", expected \"$3\""
+    fi
+}
+
+test_unsafe file			from				safe
+test_unsafe dir/file			from				safe
+test_unsafe dir/./file			from				safe
+test_unsafe dir/.			from				safe
+test_unsafe dir/			from				safe
+
+test_unsafe /etc/passwd 		from				unsafe
+test_unsafe //../etc/passwd		from				unsafe
+test_unsafe //./etc/passwd		from				unsafe
+
+test_unsafe ./foo			from				safe
+test_unsafe ../foo			from				unsafe
+test_unsafe ./../foo			from				unsafe
+test_unsafe .//../foo			from				unsafe
+test_unsafe ./../foo			from/..				unsafe
+test_unsafe ../dest			from/dir			safe
+test_unsafe ../../dest			from//dir			unsafe
+test_unsafe ..//../dest 		from/dir			unsafe
+
+test_unsafe ..				from/file			safe
+test_unsafe ../..			from/file			unsafe
+test_unsafe ..//..			from//file			unsafe
+test_unsafe dir/..			from				safe
+test_unsafe dir/../..			from				unsafe
+test_unsafe dir/..//..			from				unsafe
+
+test_unsafe ''				from				unsafe
+
+# Based on tests from unsafe-links by Vladimír Michl
+test_unsafe ../../unsafe/unsafefile	from/safe			unsafe
+test_unsafe ..//../unsafe/unsafefile	from/safe			unsafe
+test_unsafe ../files/file1		from/safe			safe
+
+test_unsafe ../../unsafe/unsafefile	safe				unsafe
+test_unsafe ../files/file1		safe				unsafe
+
+test_unsafe ../../unsafe/unsafefile	`pwd`/from/safe			safe
+test_unsafe ../files/file1		`pwd`/from/safe			safe
diff --git a/testsuite/unsafe-links.test b/testsuite/unsafe-links.test
new file mode 100644
index 0000000..2d209eb
--- /dev/null
+++ b/testsuite/unsafe-links.test
@@ -0,0 +1,65 @@
+#!/bin/sh
+
+# Originally by Vladimír Michl <Vladimir.Michl@hlubocky.del.cz>
+
+. "$suitedir/rsync.fns"
+
+test_symlink() {
+	is_a_link "$1" || test_fail "File $1 is not a symlink"
+}
+
+test_regular() {
+	if [ ! -f "$1" ]; then
+		test_fail "File $1 is not regular file or not exists"
+	fi
+}
+
+cd "$tmpdir"
+
+mkdir from
+
+mkdir "from/safe"
+mkdir "from/unsafe"
+
+mkdir "from/safe/files"
+mkdir "from/safe/links"
+
+touch "from/safe/files/file1"
+touch "from/safe/files/file2"
+touch "from/unsafe/unsafefile"
+
+ln -s ../files/file1 "from/safe/links/"
+ln -s ../files/file2 "from/safe/links/"
+ln -s ../../unsafe/unsafefile "from/safe/links/"
+
+echo "rsync with relative path and just -a"
+$RSYNC -avv from/safe/ to
+test_symlink to/links/file1
+test_symlink to/links/file2
+test_symlink to/links/unsafefile
+
+echo "rsync with relative path and -a --copy-links"
+$RSYNC -avv --copy-links from/safe/ to
+test_regular to/links/file1
+test_regular to/links/file2
+test_regular to/links/unsafefile
+
+echo "rsync with relative path and --copy-unsafe-links"
+$RSYNC -avv --copy-unsafe-links from/safe/ to
+test_symlink to/links/file1
+test_symlink to/links/file2
+test_regular to/links/unsafefile
+
+rm -rf to
+echo "rsync with relative2 path"
+(cd from; $RSYNC -avv --copy-unsafe-links safe/ ../to)
+test_symlink to/links/file1
+test_symlink to/links/file2
+test_regular to/links/unsafefile
+
+rm -rf to
+echo "rsync with absolute path"
+$RSYNC -avv --copy-unsafe-links `pwd`/from/safe/ to
+test_symlink to/links/file1
+test_symlink to/links/file2
+test_regular to/links/unsafefile
diff --git a/testsuite/wildmatch.test b/testsuite/wildmatch.test
new file mode 100644
index 0000000..cfe7584
--- /dev/null
+++ b/testsuite/wildmatch.test
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# Copyright (C) 2003-2022 Wayne Davison
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test the wildmatch functionality
+
+. "$suitedir/rsync.fns"
+
+# This test exercises the wildmatch() function (with no options) and the
+# wildmatch_join() function (using -x and/or -e).
+for opts in "" -x1 "-x1 -e1" "-x1 -e1se" -x2 "-x2 -ese" -x3 "-x3 -e1" -x4 "-x4 -e2e" -x5 "-x5 -es"; do
+    echo Running wildtest with "$opts"
+    "$TOOLDIR/wildtest" $opts "$srcdir/wildtest.txt" >"$scratchdir/wild.out"
+    diff $diffopt "$scratchdir/wild.out" - <<EOF
+No wildmatch errors found.
+EOF
+done
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0
diff --git a/testsuite/xattrs.test b/testsuite/xattrs.test
new file mode 100644
index 0000000..d94d5f9
--- /dev/null
+++ b/testsuite/xattrs.test
@@ -0,0 +1,239 @@
+#!/bin/sh
+
+# This program is distributable under the terms of the GNU GPL (see
+# COPYING).
+
+# Test that rsync handles basic xattr preservation.
+
+. $suitedir/rsync.fns
+lnkdir="$tmpdir/lnk"
+
+$RSYNC -VV | grep '"xattrs": true' >/dev/null || test_skipped "Rsync is configured without xattr support"
+
+case "$HOST_OS" in
+darwin*)
+    xset() {
+	xnam="$1"
+	xval="$2"
+	shift 2
+	xattr -s "$xnam" "$xval" "${@}"
+    }
+    xls() {
+	xattr -l "${@}" | sed "s/^[ $tab_ch]*//"
+    }
+    RSYNC_PREFIX='rsync'
+    RUSR='rsync.nonuser'
+    ;;
+solaris*)
+    xset() {
+	xnam="$1"
+	xval="$2"
+	shift 2
+	for fn in "${@}"; do
+	    runat "$fn" "$SHELL_PATH" <<EOF
+echo "${xval}" > "${xnam}"
+EOF
+	done
+    }
+    xls() {
+	for fn in "${@}"; do
+	    runat "$fn" "$SHELL_PATH" <<EOF
+for x in *; do echo "\$x=\`cat \$x\`"; done
+EOF
+       done
+    }
+    RSYNC_PREFIX='rsync'
+    RUSR='rsync.nonuser'
+    ;;
+freebsd*)
+    xset() {
+	xnam="$1"
+	xval="$2"
+	shift 2
+	setextattr -h user "$xnam" "$xval" "${@}"
+    }
+    xls() {
+	for f in "${@}"; do lsextattr -q -h user "$f" | tr '[[:space:]]' '\n' | sort | xargs -I % getextattr -h user % "$f"; done
+    }
+    RSYNC_PREFIX='rsync'
+    RUSR='rsync'
+    ;;
+*)
+    xset() {
+	xnam="$1"
+	xval="$2"
+	shift 2
+	setfattr -n "$xnam" -v "$xval" "${@}"
+    }
+    xls() {
+	getfattr -d "${@}"
+    }
+    RSYNC_PREFIX='user.rsync'
+    RUSR='user.rsync'
+    ;;
+esac
+
+makepath "$lnkdir" "$fromdir/foo/bar"
+echo now >"$fromdir/file0"
+echo something >"$fromdir/file1"
+echo else >"$fromdir/file2"
+echo deep >"$fromdir/foo/file3"
+echo normal >"$fromdir/file4"
+echo deeper >"$fromdir/foo/bar/file5"
+
+makepath "$chkdir/foo"
+echo wow >"$chkdir/file1"
+cp_touch "$fromdir/foo/file3" "$chkdir/foo"
+
+dirs='foo foo/bar'
+files='file0 file1 file2 foo/file3 file4 foo/bar/file5'
+
+uid_gid=`"$TOOLDIR/tls" "$fromdir/foo" | sed 's/^.* \([0-9][0-9]*\)\.\([0-9][0-9]*\) .*/\1:\2/'`
+
+cd "$fromdir"
+
+xset user.foo foo file0 2>/dev/null || test_skipped "Unable to set an xattr"
+xset user.bar bar file0
+
+xset user.short 'this is short' file1
+xset user.long 'this is a long attribute that will be truncated in the initial data send' file1
+xset user.good 'this is good' file1
+xset user.nice 'this is nice' file1
+
+xset user.foo foo file2
+xset user.bar bar file2
+xset user.long 'a long attribute for our new file that tests to ensure that this works' file2
+
+xset user.dir1 'need to test directory xattrs too' foo
+xset user.dir2 'another xattr' foo
+xset user.dir3 'this is one last one for the moment' foo
+
+xset user.dir4 'another dir test' foo/bar
+xset user.dir5 'one last one' foo/bar
+
+xset user.foo 'new foo' foo/file3 foo/bar/file5
+xset user.bar 'new bar' foo/file3 foo/bar/file5
+xset user.long 'this is also a long attribute that will be truncated in the initial data send' foo/file3 foo/bar/file5
+xset $RUSR.equal 'this long attribute should remain the same and not need to be transferred' foo/file3 foo/bar/file5
+
+xset user.dir0 'old extra value' "$chkdir/foo"
+xset user.dir1 'old dir value' "$chkdir/foo"
+
+xset user.short 'old short' "$chkdir/file1"
+xset user.extra 'remove me' "$chkdir/file1"
+
+xset user.foo 'old foo' "$chkdir/foo/file3"
+xset $RUSR.equal 'this long attribute should remain the same and not need to be transferred' "$chkdir/foo/file3"
+
+case $0 in
+*hlink*)
+    ln foo/bar/file5 foo/bar/file6 || test_skipped "Can't create hardlink"
+    files="$files foo/bar/file6"
+    dashH='-H'
+    altDest='--link-dest'
+    ;;
+*)
+    dashH=''
+    altDest='--copy-dest'
+    ;;
+esac
+
+xls $dirs $files >"$scratchdir/xattrs.txt"
+
+XFILT='-f-x_system.* -f-x_security.*'
+
+# OK, let's try a simple xattr copy.
+checkit "$RSYNC -avX $XFILT $dashH --super . '$chkdir/'" "$fromdir" "$chkdir"
+
+cd "$chkdir"
+xls $dirs $files | diff $diffopt "$scratchdir/xattrs.txt" -
+
+cd "$fromdir"
+
+if [ -n "$dashH" ]; then
+    for fn in $files; do
+	name=`basename $fn`
+	ln $fn ../lnk/$name
+    done
+fi
+
+checkit "$RSYNC -aiX $XFILT $dashH --super $altDest=../chk . ../to" "$fromdir" "$todir"
+
+cd "$todir"
+xls $dirs $files | diff $diffopt "$scratchdir/xattrs.txt" -
+
+[ -n "$dashH" ] && rm -rf "$lnkdir"
+
+cd "$fromdir"
+rm -rf "$todir"
+
+xset user.nice 'this is nice, but different' file1
+
+xls $dirs $files >"$scratchdir/xattrs.txt"
+
+checkit "$RSYNC -aiX $XFILT $dashH --fake-super --link-dest=../chk . ../to" "$chkdir" "$todir"
+
+cd "$todir"
+xls $dirs $files | diff $diffopt "$scratchdir/xattrs.txt" -
+
+sed -n -e '/^[^d ][^ ]*  *[^ ][^ ]*  *[^ ][^ ]*  *1 /p' "$scratchdir/ls-to" >"$scratchdir/ls-diff-all"
+grep -F -v './file1' "$scratchdir/ls-diff-all" >"$scratchdir/ls-diff" || :
+if [ -s "$scratchdir/ls-diff" ]; then
+    echo "Missing hard links on:"
+    cat "$scratchdir/ls-diff"
+    exit 1
+fi
+if [ ! -s "$scratchdir/ls-diff-all" ]; then
+    echo "Too many hard links on file1!"
+    exit 1
+fi
+
+cd "$chkdir"
+chmod go-rwx . $dirs $files
+
+xset user.nice 'this is nice, but different' file1
+xset $RSYNC_PREFIX.%stat "40000 0,0 $uid_gid" $dirs
+xset $RSYNC_PREFIX.%stat "100000 0,0 $uid_gid" $files
+
+xls $dirs $files >"$scratchdir/xattrs.txt"
+
+cd "$fromdir"
+rm -rf "$todir"
+
+# When run by a non-root tester, this checks if no-user-perm files/dirs can be copied.
+checkit "$RSYNC -aiX $XFILT $dashH --fake-super --chmod=a= . ../to" "$chkdir" "$todir" # 2>"$scratchdir/errors.txt"
+
+cd "$todir"
+xls $dirs $files | diff $diffopt "$scratchdir/xattrs.txt" -
+
+cd "$fromdir"
+rm -rf "$todir" "$chkdir"
+
+$RSYNC -aX file1 file2
+$RSYNC -aX file1 file2 ../chk/
+$RSYNC -aX --del ../chk/ .
+$RSYNC -aX file1 ../lnk/
+[ -n "$dashH" ] && ln "$chkdir/file1" ../lnk/extra-link
+
+xls file1 file2 >"$scratchdir/xattrs.txt"
+
+checkit "$RSYNC -aiiX $XFILT $dashH $altDest=../lnk . ../to" "$chkdir" "$todir"
+
+[ -n "$dashH" ] && rm ../lnk/extra-link
+
+cd "$todir"
+xls file1 file2 | diff $diffopt "$scratchdir/xattrs.txt" -
+
+cd "$fromdir"
+rm "$todir/file2"
+
+echo extra >file1
+$RSYNC -aX . ../chk/
+
+checkit "$RSYNC -aiiX $XFILT . ../to" "$chkdir" "$todir"
+
+cd "$todir"
+xls file1 file2 | diff $diffopt "$scratchdir/xattrs.txt" -
+
+# The script would have aborted on error, so getting here means we've won.
+exit 0