Merge branch 'master' of git.savannah.gnu.org:/srv/git/emacs

10 files changed, 1155 insertions, 27 deletions

diff --git a/test/Makefile.in b/test/Makefile.in
index 6070932508d..0bc893bc0c6 100644
--- a/test/Makefile.in
+++ b/test/Makefile.in
@@ -169,7 +169,6 @@ WRITE_LOG = > $@ 2>&1 || { STAT=$$?; cat $@; exit $$STAT; }
 ifdef EMACS_HYDRA_CI
 ## On Hydra, always show logs for certain problematic tests.
 lisp/net/tramp-tests.log \
-lisp/epg-tests.log \
 : WRITE_LOG = 2>&1 | tee $@
 endif
 
diff --git a/test/lisp/auth-source-tests.el b/test/lisp/auth-source-tests.el
index be516f2c40d..ca8a3eb78f0 100644
--- a/test/lisp/auth-source-tests.el
+++ b/test/lisp/auth-source-tests.el
@@ -344,5 +344,25 @@
      "session"
      (format "%s@%s" (plist-get auth-info :user) (plist-get auth-info :host)))))
 
+(ert-deftest auth-source-delete ()
+  (let* ((netrc-file (make-temp-file "auth-source-test" nil nil "\
+machine a1 port a2 user a3 password a4
+machine b1 port b2 user b3 password b4
+machine c1 port c2 user c3 password c4\n"))
+         (auth-sources (list netrc-file))
+         (auth-source-do-cache nil)
+         (expected '((:host "a1" :port "a2" :user "a3" :secret "a4")))
+         (parameters '(:max 1 :host t)))
+    (unwind-protect
+        (let ((found (apply #'auth-source-delete parameters)))
+          (dolist (f found)
+            (let ((s (plist-get f :secret)))
+              (setf f (plist-put f :secret
+                                 (if (functionp s) (funcall s) s)))))
+          ;; Note: The netrc backend doesn't delete anything, so
+          ;; this is actually the same as `auth-source-search'.
+          (should (equal found expected)))
+      (delete-file netrc-file))))
+
 (provide 'auth-source-tests)
 ;;; auth-source-tests.el ends here
diff --git a/test/lisp/emacs-lisp/lisp-mode-tests.el b/test/lisp/emacs-lisp/lisp-mode-tests.el
index 8598d419788..30f606d3816 100644
--- a/test/lisp/emacs-lisp/lisp-mode-tests.el
+++ b/test/lisp/emacs-lisp/lisp-mode-tests.el
@@ -113,6 +113,29 @@ noindent\" 3
       ;; we're indenting ends on the previous line.
       (should (equal (buffer-string) original)))))
 
+(ert-deftest indent-sexp-go ()
+  "Make sure `indent-sexp' doesn't stop after #s."
+  ;; See https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31984.
+  (with-temp-buffer
+    (emacs-lisp-mode)
+    (insert "#s(foo\nbar)\n")
+    (goto-char (point-min))
+    (indent-sexp)
+    (should (equal (buffer-string) "\
+#s(foo
+   bar)\n"))))
+
+(ert-deftest indent-sexp-cant-go ()
+  "`indent-sexp' shouldn't error before a sexp."
+  ;; See https://debbugs.gnu.org/cgi/bugreport.cgi?bug=31984#32.
+  (with-temp-buffer
+    (emacs-lisp-mode)
+    (insert "(())")
+    (goto-char (1+ (point-min)))
+    ;; Paredit calls `indent-sexp' from this position.
+    (indent-sexp)
+    (should (equal (buffer-string) "(())"))))
+
 (ert-deftest lisp-indent-region ()
   "Test basics of `lisp-indent-region'."
   (with-temp-buffer
diff --git a/test/lisp/emacs-lisp/package-tests.el b/test/lisp/emacs-lisp/package-tests.el
index b1adfabe525..f08bc92ff2a 100644
--- a/test/lisp/emacs-lisp/package-tests.el
+++ b/test/lisp/emacs-lisp/package-tests.el
@@ -473,7 +473,17 @@ Must called from within a `tar-mode' buffer."
                      (let ((process-environment
                             (cons (concat "HOME=" homedir)
                                   process-environment)))
-                       (epg-find-configuration 'OpenPGP))
+                       (epg-find-configuration
+                        'OpenPGP nil
+                        ;; By default we require gpg2 2.1+ due to some
+                        ;; practical problems with pinentry.  But this
+                        ;; test works fine with 2.0 as well.
+                        (let ((prog-alist (copy-tree epg-config--program-alist)))
+                          (setf (alist-get "gpg2"
+                                           (alist-get 'OpenPGP prog-alist)
+                                           nil nil #'equal)
+                                "2.0")
+                          prog-alist)))
                    (delete-directory homedir t))))
   (let* ((keyring (expand-file-name "key.pub" package-test-data-dir))
          (package-test-data-dir
diff --git a/test/lisp/epg-tests.el b/test/lisp/epg-tests.el
index c34e589a4ac..c1e98a6935e 100644
--- a/test/lisp/epg-tests.el
+++ b/test/lisp/epg-tests.el
@@ -23,7 +23,6 @@
 
 (require 'ert)
 (require 'epg)
-(require 'trace)
 
 (defvar epg-tests-context nil)
 
@@ -33,17 +32,26 @@
 
 (defconst epg-tests--config-program-alist
   ;; The default `epg-config--program-alist' requires gpg2 2.1 or
-  ;; greater due to some practical problems with pinentry.  But the
-  ;; tests here all work fine with 2.0 as well.
-  (let ((prog-alist (copy-sequence epg-config--program-alist)))
+  ;; greater due to some practical problems with pinentry.  But most
+  ;; tests here work fine with 2.0 as well.
+  (let ((prog-alist (copy-tree epg-config--program-alist)))
     (setf (alist-get "gpg2"
                      (alist-get 'OpenPGP prog-alist)
                      nil nil #'equal)
           "2.0")
     prog-alist))
 
-(defun epg-tests-find-usable-gpg-configuration (&optional _require-passphrase)
-  (epg-find-configuration 'OpenPGP 'no-cache epg-tests--config-program-alist))
+(defun epg-tests-find-usable-gpg-configuration
+    (&optional require-passphrase require-public-key)
+  ;; Clear config cache because we may be using a different
+  ;; program-alist.  We do want to update the cache, so that
+  ;; `epg-make-context' can use our result.
+  (setq epg--configurations nil)
+  (epg-find-configuration 'OpenPGP nil
+                          ;; The symmetric operations fail on Hydra
+                          ;; with gpg 2.0.
+                          (if (or (not require-passphrase) require-public-key)
+                              epg-tests--config-program-alist)))
 
 (defun epg-tests-passphrase-callback (_c _k _d)
   ;; Need to create a copy here, since the string will be wiped out
@@ -63,14 +71,12 @@
                   (format "GNUPGHOME=%s" epg-tests-home-directory))
             process-environment)))
      (unwind-protect
-         (let ((context (epg-make-context 'OpenPGP))
-               (epg-config (epg-tests-find-usable-gpg-configuration
-                            ,(if require-passphrase
-                                 `'require-passphrase))))
-           ;; GNUPGHOME is needed to find a usable gpg, so we can't
-           ;; check whether to skip any earlier (Bug#23561).
-           (unless epg-config
-             (ert-skip "No usable gpg config"))
+         ;; GNUPGHOME is needed to find a usable gpg, so we can't
+         ;; check whether to skip any earlier (Bug#23561).
+         (let ((epg-config (or (epg-tests-find-usable-gpg-configuration
+                                ,require-passphrase ,require-public-key)
+                               (ert-skip "No usable gpg config")))
+               (context (epg-make-context 'OpenPGP)))
            (setf (epg-context-program context)
                  (alist-get 'program epg-config))
            (setf (epg-context-home-directory context)
diff --git a/test/lisp/shadowfile-tests.el b/test/lisp/shadowfile-tests.el
new file mode 100644
index 00000000000..085ab476ffe
--- /dev/null
+++ b/test/lisp/shadowfile-tests.el
@@ -0,0 +1,932 @@
+;;; shadowfile-tests.el --- Tests of shadowfile
+
+;; Copyright (C) 2018 Free Software Foundation, Inc.
+
+;; Author: Michael Albinus <michael.albinus@gmx.de>
+
+;; This program is free software: you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation, either version 3 of the
+;; License, or (at your option) any later version.
+;;
+;; This program is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;; General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see `https://www.gnu.org/licenses/'.
+
+;;; Commentary:
+
+;; Some of the tests require access to a remote host files.  Since
+;; this could be problematic, a mock-up connection method "mock" is
+;; used.  Emulating a remote connection, it simply calls "sh -i".
+;; Tramp's file name handlers still run, so this test is sufficient
+;; except for connection establishing.
+
+;; If you want to test a real Tramp connection, set
+;; $REMOTE_TEMPORARY_FILE_DIRECTORY to a suitable value in order to
+;; overwrite the default value.  If you want to skip tests accessing a
+;; remote host, set this environment variable to "/dev/null" or
+;; whatever is appropriate on your system.
+
+;; A whole test run can be performed calling the command `shadowfile-test-all'.
+
+;;; Code:
+
+(require 'ert)
+(require 'shadowfile)
+(require 'tramp)
+
+;; There is no default value on w32 systems, which could work out of the box.
+(defconst shadow-test-remote-temporary-file-directory
+  (cond
+   ((getenv "REMOTE_TEMPORARY_FILE_DIRECTORY"))
+   ((eq system-type 'windows-nt) null-device)
+   (t (add-to-list
+       'tramp-methods
+       '("mock"
+         (tramp-login-program        "sh")
+         (tramp-login-args           (("-i")))
+         (tramp-remote-shell         "/bin/sh")
+         (tramp-remote-shell-args    ("-c"))
+         (tramp-connection-timeout   10)))
+      (add-to-list
+       'tramp-default-host-alist
+       `("\\`mock\\'" nil ,(system-name)))
+      ;; Emacs' Makefile sets $HOME to a nonexistent value.  Needed in
+      ;; batch mode only, therefore.  It cannot be
+      ;; `temporary-directory', because the tests with "~" would fail.
+      (unless (and (null noninteractive) (file-directory-p "~/"))
+        (setenv "HOME" invocation-directory))
+      (format "/mock::%s" temporary-file-directory)))
+  "Temporary directory for Tramp tests.")
+
+(defconst shadow-test-info-file
+  (expand-file-name "shadows_test" temporary-file-directory)
+  "File to keep shadow information in during tests.")
+
+(defconst shadow-test-todo-file
+  (expand-file-name "shadow_todo_test" temporary-file-directory)
+  "File to store the list of uncopied shadows in during tests.")
+
+(ert-deftest shadow-test00-clusters ()
+  "Check cluster definitions.
+Per definition, all files are identical on the different hosts of
+a cluster (or site).  This is not tested here; it must be
+guaranteed by the originator of a cluster definition."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((text-quoting-style 'grave) ;; We inspect the *Messages* buffer!
+        (inhibit-message t)
+        (shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster primary regexp mocked-input)
+    (unwind-protect
+        ;; We must mock `read-from-minibuffer' and `read-string', in
+        ;; order to avoid interactive arguments.
+        (cl-letf* (((symbol-function 'read-from-minibuffer)
+                    (lambda (&rest args) (pop mocked-input)))
+                   ((symbol-function 'read-string)
+                    (lambda (&rest args) (pop mocked-input))))
+
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster "cluster"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary)
+                mocked-input `(,cluster ,primary ,regexp))
+          (call-interactively 'shadow-define-cluster)
+          (should
+           (string-equal
+            (shadow-cluster-name (shadow-get-cluster cluster)) cluster))
+          (should
+           (string-equal
+            (shadow-cluster-primary (shadow-get-cluster cluster)) primary))
+          (should
+           (string-equal
+            (shadow-cluster-regexp (shadow-get-cluster cluster)) regexp))
+          (should-not (shadow-get-cluster "non-existent-cluster-name"))
+
+          ;; Test `shadow-set-cluster' and `make-shadow-cluster'.
+          (shadow-set-cluster cluster primary regexp)
+          (should
+           (equal (shadow-get-cluster cluster)
+                  (make-shadow-cluster
+                   :name cluster :primary primary :regexp regexp)))
+
+          ;; The primary must be either `shadow-system-name', or a remote file.
+          (setq ;; The second "cluster" is wrong.
+                mocked-input `(,cluster ,cluster ,primary ,regexp))
+          (with-current-buffer (messages-buffer)
+            (narrow-to-region (point-max) (point-max)))
+          (call-interactively 'shadow-define-cluster)
+          (should
+           (string-match
+            (regexp-quote "Not a valid primary!")
+            (with-current-buffer (messages-buffer) (buffer-string))))
+          ;; The first cluster definition is still valid.
+          (should
+           (string-equal
+            (shadow-cluster-name (shadow-get-cluster cluster)) cluster))
+          (should
+           (string-equal
+            (shadow-cluster-primary (shadow-get-cluster cluster)) primary))
+          (should
+           (string-equal
+            (shadow-cluster-regexp (shadow-get-cluster cluster)) regexp))
+
+          ;; The regexp must match the primary name.
+          (setq ;; The second "cluster" is wrong.
+                mocked-input `(,cluster ,primary ,cluster ,regexp))
+          (with-current-buffer (messages-buffer)
+            (narrow-to-region (point-max) (point-max)))
+          (call-interactively 'shadow-define-cluster)
+          (should
+           (string-match
+            (regexp-quote "Regexp doesn't include the primary host!")
+            (with-current-buffer (messages-buffer) (buffer-string))))
+          ;; The first cluster definition is still valid.
+          (should
+           (string-equal
+            (shadow-cluster-name (shadow-get-cluster cluster)) cluster))
+          (should
+           (string-equal
+            (shadow-cluster-primary (shadow-get-cluster cluster)) primary))
+          (should
+           (string-equal
+            (shadow-cluster-regexp (shadow-get-cluster cluster)) regexp))
+
+          ;; Redefine the cluster.
+          (setq primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary)
+                mocked-input `(,cluster ,primary ,regexp))
+          (call-interactively 'shadow-define-cluster)
+          (should
+           (string-equal
+            (shadow-cluster-name (shadow-get-cluster cluster)) cluster))
+          (should
+           (string-equal
+            (shadow-cluster-primary (shadow-get-cluster cluster)) primary))
+          (should
+           (string-equal
+            (shadow-cluster-regexp (shadow-get-cluster cluster)) regexp))
+
+          ;; Test `shadow-set-cluster' and `make-shadow-cluster'.
+          (shadow-set-cluster cluster primary regexp)
+          (should
+           (equal (shadow-get-cluster cluster)
+                  (make-shadow-cluster
+                   :name cluster :primary primary :regexp regexp))))
+
+      ;; Cleanup.
+      (with-current-buffer (messages-buffer) (widen))
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test01-sites ()
+  "Check site definitions.
+Per definition, all files are identical on the different hosts of
+a cluster (or site).  This is not tested here; it must be
+guaranteed by the originator of a cluster definition."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster1 cluster2 primary1 primary2 regexp1 regexp2 mocked-input)
+    (unwind-protect
+        ;; We must mock `read-from-minibuffer' and `read-string', in
+        ;; order to avoid interactive arguments.
+        (cl-letf* (((symbol-function 'read-from-minibuffer)
+                    (lambda (&rest args) (pop mocked-input)))
+                   ((symbol-function 'read-string)
+                    (lambda (&rest args) (pop mocked-input))))
+
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster1 "cluster1"
+                primary1 shadow-system-name
+                regexp1 (shadow-regexp-superquote primary1))
+          (shadow-set-cluster cluster1 primary1 regexp1)
+
+          ;; A site is either a cluster identification, or a primary host.
+          (should (string-equal cluster1 (shadow-site-name cluster1)))
+          (should (string-equal primary1 (shadow-name-site primary1)))
+          (should
+           (string-equal (format "/%s:" cluster1) (shadow-name-site cluster1)))
+          (should (string-equal (system-name) (shadow-site-name primary1)))
+          (should
+           (string-equal
+            (file-remote-p shadow-test-remote-temporary-file-directory)
+            (shadow-name-site
+             (file-remote-p shadow-test-remote-temporary-file-directory))))
+          (should
+           (string-equal
+            (file-remote-p shadow-test-remote-temporary-file-directory)
+            (shadow-site-name
+             (file-remote-p shadow-test-remote-temporary-file-directory))))
+
+          (should (equal (shadow-site-cluster cluster1)
+                         (shadow-get-cluster cluster1)))
+          (should (equal (shadow-site-cluster (shadow-name-site cluster1))
+                         (shadow-get-cluster cluster1)))
+          (should (equal (shadow-site-cluster primary1)
+                         (shadow-get-cluster cluster1)))
+          (should (equal (shadow-site-cluster (shadow-site-name primary1))
+                         (shadow-get-cluster cluster1)))
+          (should (string-equal (shadow-site-primary cluster1) primary1))
+          (should (string-equal (shadow-site-primary primary1) primary1))
+
+          ;; `shadow-read-site' accepts "cluster", "/cluster:",
+          ;; "system", "/system:".  It shall reject bad site names.
+          (setq mocked-input
+                `(,cluster1 ,(shadow-name-site cluster1)
+                  ,primary1 ,(shadow-site-name primary1)
+                  ,shadow-system-name "" "bad" "/bad:"))
+          (should (string-equal (shadow-read-site) cluster1))
+          (should (string-equal (shadow-read-site) (shadow-name-site cluster1)))
+          (should (string-equal (shadow-read-site) primary1))
+          (should (string-equal (shadow-read-site) (shadow-site-name primary1)))
+          (should (string-equal (shadow-read-site) shadow-system-name))
+          (should-not (shadow-read-site)) ; ""
+          (should-not (shadow-read-site)) ; "bad"
+          (should-not (shadow-read-site)) ; "/bad:"
+          (should-error (shadow-read-site)) ; no input at all
+
+          ;; Define a second cluster.
+          (setq cluster2 "cluster2"
+                primary2
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp2 (format "^\\(%s\\|%s\\)$" shadow-system-name primary2))
+          (shadow-set-cluster cluster2 primary2 regexp2)
+
+          ;; `shadow-site-match' shall know all different kind of site names.
+          (should (shadow-site-match cluster1 cluster1))
+          (should (shadow-site-match primary1 primary1))
+          (should (shadow-site-match cluster1 primary1))
+          (should (shadow-site-match primary1 cluster1))
+          (should (shadow-site-match cluster2 cluster2))
+          (should (shadow-site-match primary2 primary2))
+          (should (shadow-site-match cluster2 primary2))
+          (should (shadow-site-match primary2 cluster2))
+
+          ;; The regexp of `cluster2' matches the primary of
+          ;; `cluster1'.  Not vice versa.
+          (should (shadow-site-match cluster2 cluster1))
+          (should-not (shadow-site-match cluster1 cluster2))
+
+          ;; If we use the primaries of a cluster, it doesn't match.
+          (should-not
+           (shadow-site-match (shadow-site-primary cluster2) cluster1))
+          (should-not
+           (shadow-site-match (shadow-site-primary cluster1) cluster2)))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test02-files ()
+  "Check file manipulation functions."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster primary regexp file hup)
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster "cluster"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary)
+                file (make-temp-name
+                      (expand-file-name
+                       "shadowfile-tests" temporary-file-directory)))
+          (shadow-set-cluster cluster primary regexp)
+
+          ;; The constant structure to compare with.
+          (setq hup (make-tramp-file-name :host (system-name) :localname file))
+
+          ;; The structure a local file is transformed in.
+          (should (equal (shadow-parse-name file) hup))
+          (should (equal (shadow-parse-name (concat "/" cluster ":" file)) hup))
+          (should (equal (shadow-parse-name (concat primary file)) hup))
+
+          ;; A local file name is kept.
+          (should
+           (string-equal (shadow-local-file file) file))
+          ;; A file on this cluster is also local.
+          (should
+           (string-equal
+            (shadow-local-file (concat "/" cluster ":" file)) file))
+          ;; A file on the primary host is also local.
+          (should
+           (string-equal (shadow-local-file (concat primary file)) file))
+
+          ;; Redefine the cluster.
+          (setq primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster primary regexp)
+
+          ;; The structure of the local file is still the same.
+          (should (equal (shadow-parse-name file) hup))
+          ;; The cluster name must be used.
+          (setf (tramp-file-name-host hup) cluster)
+          (should (equal (shadow-parse-name (concat "/" cluster ":" file)) hup))
+          ;; The structure of a remote file is different.
+          (should
+           (equal (shadow-parse-name (concat primary file))
+                  (tramp-dissect-file-name (concat primary file))))
+
+          ;; A local file is still local.
+          (should (shadow-local-file file))
+          ;; A file on this cluster is not local.
+          (should-not (shadow-local-file (concat "/" cluster ":" file)))
+          ;; A file on the primary host is not local.
+          (should-not (shadow-local-file (concat primary file)))
+          ;; There's no error on wrong FILE.
+          (should-not (shadow-local-file nil)))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test03-expand-cluster-in-file-name ()
+  "Check canonical file name of a cluster or site."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster primary regexp file1 file2)
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster "cluster"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster primary regexp)
+
+          (setq file1
+                (make-temp-name
+                 (expand-file-name "shadowfile-tests" temporary-file-directory))
+                file2
+                (make-temp-name
+                 (expand-file-name
+                  "shadowfile-tests"
+                  shadow-test-remote-temporary-file-directory)))
+
+          ;; A local file name is kept.
+          (should
+           (string-equal (shadow-expand-cluster-in-file-name file1) file1))
+          ;; A remote file is kept.
+          (should
+           (string-equal (shadow-expand-cluster-in-file-name file2) file2))
+          ;; A cluster name is expanded to the primary name.
+          (should
+           (string-equal
+            (shadow-expand-cluster-in-file-name (format "/%s:%s" cluster file1))
+            (shadow-expand-cluster-in-file-name (concat primary file1))))
+          ;; A primary name is expanded if it is a local file name.
+          (should
+           (string-equal
+            (shadow-expand-cluster-in-file-name (concat primary file1)) file1))
+
+          ;; Redefine the cluster.
+          (setq primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster primary regexp)
+
+          ;; A cluster name is expanded to the primary name.
+          (should
+           (string-equal
+            (shadow-expand-cluster-in-file-name (format "/%s:%s" cluster file1))
+            (shadow-expand-cluster-in-file-name (concat primary file1))))
+          ;; A primary name is not expanded if it isn't is a local file name.
+          (should
+           (string-equal
+            (shadow-expand-cluster-in-file-name (concat primary file1))
+            (concat primary file1))))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test04-contract-file-name ()
+  "Check canonical file name of a cluster or site."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster primary regexp file)
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster "cluster"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary)
+                file (make-temp-name
+                      (expand-file-name
+                       "shadowfile-tests" temporary-file-directory)))
+          (shadow-set-cluster cluster primary regexp)
+
+          ;; The cluster name is prepended for local files.
+          (should
+           (string-equal
+            (shadow-contract-file-name file) (concat "/cluster:" file)))
+          ;; A cluster file name is preserved.
+          (should
+           (string-equal
+            (shadow-contract-file-name (concat "/cluster:" file))
+            (concat "/cluster:" file)))
+          ;; `shadow-system-name' is mapped to the cluster.
+          (should
+           (string-equal
+            (shadow-contract-file-name (concat shadow-system-name file))
+            (concat "/cluster:" file)))
+
+          ;; Redefine the cluster.
+          (setq primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster primary regexp)
+
+          ;; A remote file name is mapped to the cluster.
+          (should
+           (string-equal
+            (shadow-contract-file-name
+             (concat
+              (file-remote-p shadow-test-remote-temporary-file-directory) file))
+            (concat "/cluster:" file))))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test05-file-match ()
+  "Check `shadow-same-site' and `shadow-file-match'."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters
+        cluster primary regexp file)
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define a cluster.
+          (setq cluster "cluster"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary)
+                file (make-temp-name
+                      (expand-file-name
+                       "shadowfile-tests" temporary-file-directory)))
+          (shadow-set-cluster cluster primary regexp)
+
+          (should (shadow-same-site (shadow-parse-name "/cluster:") file))
+          (should
+           (shadow-same-site (shadow-parse-name shadow-system-name) file))
+          (should (shadow-same-site (shadow-parse-name file) file))
+
+          (should
+           (shadow-file-match
+            (shadow-parse-name (concat "/cluster:" file)) file))
+          (should
+           (shadow-file-match
+            (shadow-parse-name (concat shadow-system-name file)) file))
+          (should (shadow-file-match (shadow-parse-name file) file))
+
+          ;; Redefine the cluster.
+          (setq primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster primary regexp)
+
+          (should
+           (shadow-file-match
+            (shadow-parse-name
+             (concat
+              (file-remote-p shadow-test-remote-temporary-file-directory)
+              file))
+            file)))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test06-literal-groups ()
+  "Check literal group definitions."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters shadow-literal-groups
+        cluster1 cluster2 primary regexp file1 file2 mocked-input)
+    (unwind-protect
+        ;; We must mock `read-from-minibuffer' and `read-string', in
+        ;; order to avoid interactive arguments.
+        (cl-letf* (((symbol-function 'read-from-minibuffer)
+                    (lambda (&rest args) (pop mocked-input)))
+                   ((symbol-function 'read-string)
+                    (lambda (&rest args) (pop mocked-input))))
+
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define clusters.
+          (setq cluster1 "cluster1"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster1 primary regexp)
+
+          (setq cluster2 "cluster2"
+                primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (format "^\\(%s\\|%s\\)$" shadow-system-name primary))
+          (shadow-set-cluster cluster2 primary regexp)
+
+          ;; Define a literal group.
+          (setq file1
+                (make-temp-name
+                 (expand-file-name "shadowfile-tests" temporary-file-directory))
+                file2
+                (make-temp-name
+                 (expand-file-name
+                  "shadowfile-tests"
+                  shadow-test-remote-temporary-file-directory))
+                mocked-input `(,cluster1 ,file1 ,cluster2 ,file2 ,(kbd "RET")))
+          (with-temp-buffer
+            (setq-local buffer-file-name file1)
+            (call-interactively 'shadow-define-literal-group))
+
+          ;; `shadow-literal-groups' is a list of lists.
+          (should (consp shadow-literal-groups))
+          (should (consp (car shadow-literal-groups)))
+          (should-not (cdr shadow-literal-groups))
+
+          (should (member (format "/%s:%s" cluster1 (file-local-name file1))
+                          (car shadow-literal-groups)))
+          (should (member (format "/%s:%s" cluster2 (file-local-name file2))
+                          (car shadow-literal-groups))))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test07-regexp-groups ()
+  "Check regexp group definitions."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        shadow-clusters shadow-regexp-groups
+        cluster1 cluster2 primary regexp file mocked-input)
+    (unwind-protect
+        ;; We must mock `read-from-minibuffer' and `read-string', in
+        ;; order to avoid interactive arguments.
+        (cl-letf* (((symbol-function 'read-from-minibuffer)
+                    (lambda (&rest args) (pop mocked-input)))
+                   ((symbol-function 'read-string)
+                    (lambda (&rest args) (pop mocked-input))))
+
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          ;; Define clusters.
+          (setq cluster1 "cluster1"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster1 primary regexp)
+
+          (setq cluster2 "cluster2"
+                primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (format "^\\(%s\\|%s\\)$" shadow-system-name primary))
+          (shadow-set-cluster cluster2 primary regexp)
+
+          ;; Define a regexp group.
+          (setq file
+                (make-temp-name
+                 (expand-file-name "shadowfile-tests" temporary-file-directory))
+                mocked-input `(,(shadow-regexp-superquote file)
+                               ,cluster1 ,cluster2 ,(kbd "RET")))
+          (with-temp-buffer
+            (setq-local buffer-file-name nil)
+            (call-interactively 'shadow-define-regexp-group))
+
+          ;; `shadow-regexp-groups' is a list of lists.
+          (should (consp shadow-regexp-groups))
+          (should (consp (car shadow-regexp-groups)))
+          (should-not (cdr shadow-regexp-groups))
+
+          (should
+           (member
+            (concat
+             (shadow-site-primary cluster1) (shadow-regexp-superquote file))
+            (car shadow-regexp-groups)))
+          (should
+           (member
+            (concat
+             (shadow-site-primary cluster2) (shadow-regexp-superquote file))
+            (car shadow-regexp-groups))))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file)))))
+
+(ert-deftest shadow-test08-shadow-todo ()
+  "Check that needed shadows are added to todo."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+  (skip-unless (file-writable-p shadow-test-remote-temporary-file-directory))
+
+  (let ((backup-inhibited t)
+        (shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        (shadow-inhibit-message t)
+        shadow-clusters shadow-literal-groups shadow-regexp-groups
+        shadow-files-to-copy
+        cluster1 cluster2 primary regexp file)
+    (unwind-protect
+        (condition-case err
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+
+          (message "Point 1")
+          ;; Define clusters.
+          (setq cluster1 "cluster1"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster1 primary regexp)
+
+          (setq cluster2 "cluster2"
+                primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster2 primary regexp)
+
+          (message "Point 2")
+          ;; Define a literal group.
+          (setq file
+                (make-temp-name
+                 (expand-file-name "shadowfile-tests" temporary-file-directory))
+                shadow-literal-groups
+                `((,(concat "/cluster1:" file) ,(concat "/cluster2:" file))))
+
+          (message "Point 3")
+          ;; Save file from "cluster1" definition.
+          (with-temp-buffer
+            (setq buffer-file-name file)
+            (insert "foo")
+            (save-buffer))
+          (message "%s" file)
+          (message "%s" (shadow-contract-file-name (concat "/cluster2:" file)))
+          (message "%s" shadow-files-to-copy)
+          (should
+           (member
+            (cons file (shadow-contract-file-name (concat "/cluster2:" file)))
+            shadow-files-to-copy))
+
+          (message "Point 4")
+          ;; Save file from "cluster2" definition.
+          (with-temp-buffer
+            (message "Point 4.1")
+            (message "%s" file)
+            (message "%s" (shadow-site-primary cluster2))
+            (setq buffer-file-name (concat (shadow-site-primary cluster2) file))
+            (message "Point 4.2")
+            (insert "foo")
+            (message "%s" buffer-file-name)
+            (save-buffer))
+          (message "Point 4.3")
+          (message "%s" (shadow-site-primary cluster2))
+          (message "%s" (shadow-contract-file-name (concat "/cluster1:" file)))
+          (message "%s" shadow-files-to-copy)
+          (should
+           (member
+            (cons
+             (concat (shadow-site-primary cluster2) file)
+             (shadow-contract-file-name (concat "/cluster1:" file)))
+            shadow-files-to-copy))
+
+          (message "Point 5")
+          ;; Define a regexp group.
+          (setq shadow-files-to-copy nil
+                shadow-regexp-groups
+                `((,(concat (shadow-site-primary cluster1)
+                            (shadow-regexp-superquote file))
+                   ,(concat (shadow-site-primary cluster2)
+                            (shadow-regexp-superquote file)))))
+
+          (message "Point 6")
+          ;; Save file from "cluster1" definition.
+          (with-temp-buffer
+            (setq buffer-file-name file)
+            (insert "foo")
+            (save-buffer))
+          (should
+           (member
+            (cons file (shadow-contract-file-name (concat "/cluster2:" file)))
+            shadow-files-to-copy))
+
+          (message "Point 7")
+          ;; Save file from "cluster2" definition.
+          (with-temp-buffer
+            (setq buffer-file-name (concat (shadow-site-primary cluster2) file))
+            (insert "foo")
+            (save-buffer))
+          (should
+           (member
+            (cons
+             (concat (shadow-site-primary cluster2) file)
+             (shadow-contract-file-name (concat "/cluster1:" file)))
+            shadow-files-to-copy)))
+        (error (message "Error: %s" err) (signal (car err) (cdr err))))
+
+      ;; Cleanup.
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file))
+      (ignore-errors
+        (when (file-exists-p file)
+          (delete-file file)))
+      (ignore-errors
+        (when (file-exists-p (concat (shadow-site-primary cluster2) file))
+          (delete-file (concat (shadow-site-primary cluster2) file)))))))
+
+(ert-deftest shadow-test09-shadow-copy-files ()
+  "Check that needed shadow files are copied."
+  (skip-unless (not (memq system-type '(windows-nt ms-dos))))
+  (skip-unless (file-remote-p shadow-test-remote-temporary-file-directory))
+
+  (let ((backup-inhibited t)
+        (shadow-info-file shadow-test-info-file)
+        (shadow-todo-file shadow-test-todo-file)
+        (shadow-inhibit-message t)
+        (shadow-noquery t)
+        shadow-clusters shadow-files-to-copy
+        cluster1 cluster2 primary regexp file mocked-input)
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (when (file-exists-p shadow-info-file)
+            (delete-file shadow-info-file))
+          (when (file-exists-p shadow-todo-file)
+            (delete-file shadow-todo-file))
+          (when (buffer-live-p shadow-todo-buffer)
+            (with-current-buffer shadow-todo-buffer (erase-buffer)))
+
+          ;; Define clusters.
+          (setq cluster1 "cluster1"
+                primary shadow-system-name
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster1 primary regexp)
+
+          (setq cluster2 "cluster2"
+                primary
+                (file-remote-p shadow-test-remote-temporary-file-directory)
+                regexp (shadow-regexp-superquote primary))
+          (shadow-set-cluster cluster2 primary regexp)
+
+          ;; Define files to copy.
+          (setq file
+                (make-temp-name
+                 (expand-file-name "shadowfile-tests" temporary-file-directory))
+                shadow-literal-groups
+                `((,(concat "/cluster1:" file) ,(concat "/cluster2:" file)))
+                shadow-regexp-groups
+                `((,(concat (shadow-site-primary cluster1)
+                            (shadow-regexp-superquote file))
+                   ,(concat (shadow-site-primary cluster2)
+                            (shadow-regexp-superquote file))))
+                mocked-input `(,(concat (shadow-site-primary cluster2) file)
+                               ,file))
+
+          ;; Save files.
+          (with-temp-buffer
+            (setq buffer-file-name file)
+            (insert "foo")
+            (save-buffer))
+          (with-temp-buffer
+            (setq buffer-file-name (concat (shadow-site-primary cluster2) file))
+            (insert "foo")
+            (save-buffer))
+
+          ;; We must mock `write-region', in order to check proper
+          ;; action.
+          (add-function
+           :before (symbol-function 'write-region)
+           (lambda (&rest args)
+             (when (and (buffer-file-name) mocked-input)
+               (should (equal (buffer-file-name) (pop mocked-input)))))
+           '((name . "write-region-mock")))
+
+          ;; Copy the files.
+          (shadow-copy-files 'noquery)
+          (should-not shadow-files-to-copy)
+          (with-current-buffer shadow-todo-buffer
+            (goto-char (point-min))
+            (should
+             (looking-at (regexp-quote "(setq shadow-files-to-copy nil)")))))
+
+      ;; Cleanup.
+      (remove-function (symbol-function 'write-region) "write-region-mock")
+      (when (file-exists-p shadow-info-file)
+        (delete-file shadow-info-file))
+      (when (file-exists-p shadow-todo-file)
+        (delete-file shadow-todo-file))
+      (ignore-errors
+        (when (file-exists-p file)
+          (delete-file file)))
+      (ignore-errors
+        (when (file-exists-p (concat (shadow-site-primary cluster2) file))
+          (delete-file (concat (shadow-site-primary cluster2) file)))))))
+
+(defun shadowfile-test-all (&optional interactive)
+  "Run all tests for \\[shadowfile]."
+  (interactive "p")
+  (if interactive
+      (ert-run-tests-interactively "^shadowfile-")
+    (ert-run-tests-batch "^shadowfile-")))
+
+(let ((shadow-info-file shadow-test-info-file)
+      (shadow-todo-file shadow-test-todo-file))
+  (shadow-initialize))
+
+(provide 'shadowfile-tests)
+;;; shadowfile-tests.el ends here
diff --git a/test/lisp/wdired-tests.el b/test/lisp/wdired-tests.el
new file mode 100644
index 00000000000..7199470ea96
--- /dev/null
+++ b/test/lisp/wdired-tests.el
@@ -0,0 +1,105 @@
+;;; wdired-tests.el --- tests for wdired.el          -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2018 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'ert)
+(require 'dired)
+
+(ert-deftest wdired-test-bug32173-01 ()
+  "Test using non-nil wdired-use-interactive-rename.
+Partially modifying a file name should succeed."
+  (let* ((test-dir (make-temp-file "test-dir-" t))
+         (test-file (concat (file-name-as-directory test-dir) "foo.c"))
+         (replace "bar")
+         (new-file (replace-regexp-in-string "foo" replace test-file))
+         (wdired-use-interactive-rename t))
+    (write-region "" nil test-file nil 'silent)
+    (advice-add 'dired-query ; Don't ask confirmation to overwrite a file.
+                :override
+                (lambda (_sym _prompt &rest _args) (setq dired-query t))
+                '((name . "advice-dired-query")))
+    (let ((buf (find-file-noselect test-dir)))
+      (unwind-protect
+          (with-current-buffer buf
+            (should (equal (dired-file-name-at-point) test-file))
+            (dired-toggle-read-only)
+            (kill-region (point) (progn (search-forward ".")
+                                        (forward-char -1) (point)))
+            (insert replace)
+            (wdired-finish-edit)
+            (should (equal (dired-file-name-at-point) new-file)))
+        (if buf (kill-buffer buf))
+        (delete-directory test-dir t)))))
+
+(ert-deftest wdired-test-bug32173-02 ()
+  "Test using non-nil wdired-use-interactive-rename.
+Aborting an edit should leaving original file name unchanged."
+  (let* ((test-dir (make-temp-file "test-dir-" t))
+         (test-file (concat (file-name-as-directory test-dir) "foo.c"))
+         (wdired-use-interactive-rename t))
+    (write-region "" nil test-file nil 'silent)
+    ;; Make dired-do-create-files-regexp a noop to mimic typing C-g
+    ;; at its prompt before wdired-finish-edit returns.
+    (advice-add 'dired-do-create-files-regexp
+                :override
+                (lambda (&rest _) (ignore))
+                '((name . "advice-dired-do-create-files-regexp")))
+    (let ((buf (find-file-noselect test-dir)))
+      (unwind-protect
+          (with-current-buffer buf
+            (should (equal (dired-file-name-at-point) test-file))
+            (dired-toggle-read-only)
+            (kill-region (point) (progn (search-forward ".")
+                                        (forward-char -1) (point)))
+            (insert "bar")
+            (wdired-finish-edit)
+            (should (equal (dired-get-filename) test-file)))
+        (if buf (kill-buffer buf))
+        (delete-directory test-dir t)))))
+
+(ert-deftest wdired-test-unfinished-edit-01 ()
+  "Test editing a file name without saving the change.
+Finding the new name should be possible while still in
+wdired-mode."
+  :expected-result (if (< emacs-major-version 27) :failed :passed)
+  (let* ((test-dir (make-temp-file "test-dir-" t))
+         (test-file (concat (file-name-as-directory test-dir) "foo.c"))
+         (replace "bar")
+         (new-file (replace-regexp-in-string "foo" replace test-file)))
+    (write-region "" nil test-file nil 'silent)
+    (let ((buf (find-file-noselect test-dir)))
+      (unwind-protect
+          (with-current-buffer buf
+            (should (equal (dired-file-name-at-point) test-file))
+            (dired-toggle-read-only)
+            (kill-region (point) (progn (search-forward ".")
+                                        (forward-char -1) (point)))
+            (insert replace)
+            (should (equal (dired-get-filename) new-file))))
+        (when buf
+          (with-current-buffer buf
+            ;; Prevent kill-buffer-query-functions from chiming in.
+            (set-buffer-modified-p nil)
+            (kill-buffer buf)))
+        (delete-directory test-dir t))))
+
+
+(provide 'wdired-tests)
+;;; wdired-tests.el ends here
diff --git a/test/src/editfns-tests.el b/test/src/editfns-tests.el
index c828000bb4f..2951270dbf7 100644
--- a/test/src/editfns-tests.el
+++ b/test/src/editfns-tests.el
@@ -165,10 +165,12 @@
                 :type 'overflow-error)
   (should-error (read (substring (format "%d" most-negative-fixnum) 1))
                 :type 'overflow-error)
-  (should-error (read (format "#x%x" most-negative-fixnum))
-                :type 'overflow-error)
-  (should-error (read (format "#o%o" most-negative-fixnum))
-                :type 'overflow-error)
+  (let ((binary-as-unsigned nil))
+    (dolist (fmt '("%d" "%s" "#o%o" "#x%x"))
+      (dolist (val (list most-negative-fixnum (1+ most-negative-fixnum)
+                         -1 0 1
+                         (1- most-positive-fixnum) most-positive-fixnum))
+        (should (eq val (read (format fmt val)))))))
   (should-error (read (format "#32rG%x" most-positive-fixnum))
                 :type 'overflow-error))
 
diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el
index d9cca557cf2..e4b9cbe25a4 100644
--- a/test/src/fns-tests.el
+++ b/test/src/fns-tests.el
@@ -23,6 +23,17 @@
 
 (require 'cl-lib)
 
+;; Test that equality predicates work correctly on NaNs when combined
+;; with hash tables based on those predicates.  This was not the case
+;; for eql in Emacs 26.
+(ert-deftest fns-tests-equality-nan ()
+  (dolist (test (list #'eq #'eql #'equal))
+    (let* ((h (make-hash-table :test test))
+           (nan 0.0e+NaN)
+           (-nan (- nan)))
+      (puthash nan t h)
+      (should (eq (funcall test nan -nan) (gethash -nan h))))))
+
 (ert-deftest fns-tests-reverse ()
   (should-error (reverse))
   (should-error (reverse 1))
diff --git a/test/src/thread-tests.el b/test/src/thread-tests.el
index a00a9c84bd6..364f6d61f05 100644
--- a/test/src/thread-tests.el
+++ b/test/src/thread-tests.el
@@ -34,10 +34,11 @@
 (declare-function thread--blocker "thread.c" (thread))
 (declare-function thread-alive-p "thread.c" (thread))
 (declare-function thread-join "thread.c" (thread))
-(declare-function thread-last-error "thread.c" ())
+(declare-function thread-last-error "thread.c" (&optional cleanup))
 (declare-function thread-name "thread.c" (thread))
 (declare-function thread-signal "thread.c" (thread error-symbol data))
 (declare-function thread-yield "thread.c" ())
+(defvar main-thread)
 
 (ert-deftest threads-is-one ()
   "Test for existence of a thread."
@@ -71,6 +72,11 @@
   (skip-unless (featurep 'threads))
   (should (listp (all-threads))))
 
+(ert-deftest threads-main-thread ()
+  "Simple test for all-threads."
+  (skip-unless (featurep 'threads))
+  (should (eq main-thread (car (all-threads)))))
+
 (defvar threads-test-global nil)
 
 (defun threads-test-thread1 ()
@@ -94,15 +100,24 @@
    (progn
      (setq threads-test-global nil)
      (let ((thread (make-thread #'threads-test-thread1)))
-       (thread-join thread)
-       (and threads-test-global
-            (not (thread-alive-p thread)))))))
+       (and (= (thread-join thread) 23)
+            (= threads-test-global 23)
+            (not (thread-alive-p thread)))))))
 
 (ert-deftest threads-join-self ()
   "Cannot `thread-join' the current thread."
   (skip-unless (featurep 'threads))
   (should-error (thread-join (current-thread))))
 
+(ert-deftest threads-join-error ()
+  "Test of error signalling from `thread-join'."
+  :tags '(:unstable)
+  (skip-unless (featurep 'threads))
+  (let ((thread (make-thread #'threads-call-error)))
+    (while (thread-alive-p thread)
+      (thread-yield))
+    (should-error (thread-join thread))))
+
 (defvar threads-test-binding nil)
 
 (defun threads-test-thread2 ()
@@ -191,7 +206,7 @@
 (ert-deftest threads-mutex-signal ()
   "Test signaling a blocked thread."
   (skip-unless (featurep 'threads))
-  (should
+  (should-error
    (progn
      (setq threads-mutex (make-mutex))
      (setq threads-mutex-key nil)
@@ -200,8 +215,10 @@
        (while (not threads-mutex-key)
          (thread-yield))
        (thread-signal thr 'quit nil)
-       (thread-join thr))
-     t)))
+       ;; `quit' is not catched by `should-error'.  We must indicate it.
+       (condition-case nil
+           (thread-join thr)
+         (quit (signal 'error nil)))))))
 
 (defun threads-test-io-switch ()
   (setq threads-test-global 23))
@@ -275,6 +292,9 @@
       (thread-yield))
     (should (equal (thread-last-error)
                    '(error "Error is called")))
+    (should (equal (thread-last-error 'cleanup)
+                   '(error "Error is called")))
+    (should-not (thread-last-error))
     (setq th2 (make-thread #'threads-custom "threads-custom"))
     (should (threadp th2))))