14 files changed, 713 insertions, 123 deletions

diff --git a/test/lisp/auth-source-tests.el b/test/lisp/auth-source-tests.el
index 2634777c7db..9753029f198 100644
--- a/test/lisp/auth-source-tests.el
+++ b/test/lisp/auth-source-tests.el
@@ -215,7 +215,7 @@
 
 (ert-deftest auth-source-test-remembrances-of-things-past ()
   (let ((password-cache t)
-        (password-data (make-vector 7 0)))
+        (password-data (copy-hash-table password-data)))
     (auth-source-remember '(:host "wedd") '(4 5 6))
     (should (auth-source-remembered-p '(:host "wedd")))
     (should-not (auth-source-remembered-p '(:host "xedd")))
diff --git a/test/lisp/dired-tests.el b/test/lisp/dired-tests.el
index 69331457c0e..981afdd929e 100644
--- a/test/lisp/dired-tests.el
+++ b/test/lisp/dired-tests.el
@@ -21,7 +21,6 @@
 (require 'ert)
 (require 'dired)
 (require 'nadvice)
-(require 'ls-lisp)
 
 (ert-deftest dired-autoload ()
   "Tests to see whether dired-x has been autoloaded"
@@ -55,10 +54,20 @@
         (when (buffer-live-p buf) (kill-buffer buf)))
       (delete-directory dir 'recursive))))
 
+(defvar dired-dwim-target)
 (ert-deftest dired-test-bug25609 ()
   "Test for http://debbugs.gnu.org/25609 ."
   (let* ((from (make-temp-file "foo" 'dir))
+         ;; Make sure we have long file-names in 'from' and 'to', not
+         ;; their 8+3 short aliases, because the latter will confuse
+         ;; Dired commands invoked below.
+         (from (if (memq system-type '(ms-dos windows-nt))
+                   (file-truename from)
+                 from))
          (to (make-temp-file "bar" 'dir))
+         (to (if (memq system-type '(ms-dos windows-nt))
+                 (file-truename to)
+                 to))
          (target (expand-file-name (file-name-nondirectory from) to))
          (nested (expand-file-name (file-name-nondirectory from) target))
          (dired-dwim-target t)
@@ -68,20 +77,30 @@
                 :override
                 (lambda (_sym _prompt &rest _args) (setq dired-query t))
                 '((name . "advice-dired-query")))
-    (advice-add 'completing-read ; Just return init.
+    (advice-add 'completing-read ; Don't prompt me: just return init.
                 :override
                 (lambda (_prompt _coll &optional _pred _match init _hist _def _inherit _keymap)
                   init)
                 '((name . "advice-completing-read")))
+    (delete-other-windows) ; We don't want to display any other dired buffers.
     (push (dired to) buffers)
     (push (dired-other-window temporary-file-directory) buffers)
-    (dired-goto-file from)
-    (dired-do-copy)
-    (dired-do-copy); Again.
     (unwind-protect
-        (progn
-          (should (file-exists-p target))
-          (should-not (file-exists-p nested)))
+        (let ((ok-fn
+               (lambda ()
+                 (let ((win-buffers (mapcar #'window-buffer (window-list))))
+                   (and (memq (car buffers) win-buffers)
+                        (memq (cadr buffers) win-buffers))))))
+          (dired-goto-file from)
+          ;; Right before `dired-do-copy' call, to reproduce the bug conditions,
+          ;; ensure we have windows displaying the two dired buffers.
+          (and (funcall ok-fn) (dired-do-copy))
+          ;; Call `dired-do-copy' again: this must overwrite `target'; if the bug
+          ;; still exists, then it creates `nested' instead.
+          (when (funcall ok-fn)
+            (dired-do-copy)
+            (should (file-exists-p target))
+            (should-not (file-exists-p nested))))
       (dolist (buf buffers)
         (when (buffer-live-p buf) (kill-buffer buf)))
       (delete-directory from 'recursive)
@@ -89,10 +108,94 @@
       (advice-remove 'dired-query "advice-dired-query")
       (advice-remove 'completing-read "advice-completing-read"))))
 
-(ert-deftest dired-test-bug27243 ()
-  "Test for http://debbugs.gnu.org/27243 ."
+;; (ert-deftest dired-test-bug27243 ()
+;;   "Test for http://debbugs.gnu.org/27243 ."
+;;   (let ((test-dir (make-temp-file "test-dir-" t))
+;;         (dired-auto-revert-buffer t) buffers)
+;;     (with-current-buffer (find-file-noselect test-dir)
+;;       (make-directory "test-subdir"))
+;;     (push (dired test-dir) buffers)
+;;     (unwind-protect
+;;         (let ((buf (current-buffer))
+;;               (pt1 (point))
+;;               (test-file (concat (file-name-as-directory "test-subdir")
+;;                                  "test-file")))
+;;           (write-region "Test" nil test-file nil 'silent nil 'excl)
+;;           ;; Sanity check: point should now be on the subdirectory.
+;;           (should (equal (dired-file-name-at-point)
+;;                          (concat (file-name-as-directory test-dir)
+;;                                  (file-name-as-directory "test-subdir"))))
+;;           (push (dired-find-file) buffers)
+;;           (let ((pt2 (point)))          ; Point is on test-file.
+;;             (switch-to-buffer buf)
+;;             ;; Sanity check: point should now be back on the subdirectory.
+;;             (should (eq (point) pt1))
+;;             ;; Case 1: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#5
+;;             (push (dired-find-file) buffers)
+;;             (should (eq (point) pt2))
+;;             ;; Case 2: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#28
+;;             (push (dired test-dir) buffers)
+;;             (should (eq (point) pt1))))
+;;       (dolist (buf buffers)
+;;         (when (buffer-live-p buf) (kill-buffer buf)))
+;;       (delete-directory test-dir t))))
+
+(ert-deftest dired-test-bug27243-01 ()
+  "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#5 ."
+  (let* ((test-dir (file-name-as-directory (make-temp-file "test-dir-" t)))
+         (save-pos (lambda ()
+                     (with-current-buffer (car (dired-buffers-for-dir test-dir))
+                       (dired-save-positions))))
+         (dired-auto-revert-buffer t) buffers)
+    ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
+    ;; corresponding long file names exist, otherwise such names trip
+    ;; dired-buffers-for-dir.
+    (if (eq system-type 'windows-nt)
+        (setq test-dir (file-truename test-dir)))
+    (should-not (dired-buffers-for-dir test-dir))
+    (with-current-buffer (find-file-noselect test-dir)
+      (make-directory "test-subdir"))
+    (message "Saved pos: %S" (funcall save-pos))
+    ;; Point must be at end-of-buffer.
+    (with-current-buffer (car (dired-buffers-for-dir test-dir))
+      (should (eobp)))
+    (push (dired test-dir) buffers)
+    (message "Saved pos: %S" (funcall save-pos))
+    ;; Previous dired call shouldn't create a new buffer: must visit the one
+    ;; created by `find-file-noselect' above.
+    (should (eq 1 (length (dired-buffers-for-dir test-dir))))
+    (unwind-protect
+        (let ((buf (current-buffer))
+              (pt1 (point))
+              (test-file (concat (file-name-as-directory "test-subdir")
+                                 "test-file")))
+          (message "Saved pos: %S" (funcall save-pos))
+          (write-region "Test" nil test-file nil 'silent nil 'excl)
+          (message "Saved pos: %S" (funcall save-pos))
+          ;; Sanity check: point should now be on the subdirectory.
+          (should (equal (dired-file-name-at-point)
+                         (concat test-dir (file-name-as-directory "test-subdir"))))
+          (message "Saved pos: %S" (funcall save-pos))
+          (push (dired-find-file) buffers)
+          (let ((pt2 (point)))          ; Point is on test-file.
+            (pop-to-buffer-same-window buf)
+            ;; Sanity check: point should now be back on the subdirectory.
+            (should (eq (point) pt1))
+            (push (dired-find-file) buffers)
+            (should (eq (point) pt2))))
+      (dolist (buf buffers)
+        (when (buffer-live-p buf) (kill-buffer buf)))
+      (delete-directory test-dir t))))
+
+(ert-deftest dired-test-bug27243-02 ()
+  "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#28 ."
   (let ((test-dir (make-temp-file "test-dir-" t))
         (dired-auto-revert-buffer t) buffers)
+    ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
+    ;; corresponding long file names exist, otherwise such names trip
+    ;; string comparisons below.
+    (if (eq system-type 'windows-nt)
+        (setq test-dir (file-truename test-dir)))
     (with-current-buffer (find-file-noselect test-dir)
       (make-directory "test-subdir"))
     (push (dired test-dir) buffers)
@@ -111,30 +214,44 @@
             (switch-to-buffer buf)
             ;; Sanity check: point should now be back on the subdirectory.
             (should (eq (point) pt1))
-            ;; Case 1: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#5
-            (push (dired-find-file) buffers)
-            (should (eq (point) pt2))
-            ;; Case 2: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#28
             (push (dired test-dir) buffers)
             (should (eq (point) pt1))))
       (dolist (buf buffers)
         (when (buffer-live-p buf) (kill-buffer buf)))
       (delete-directory test-dir t))))
 
-(ert-deftest dired-test-bug27693 ()
-  "Test for http://debbugs.gnu.org/27693 ."
-  (let ((dir (expand-file-name "lisp" source-directory))
-        (size "")
-        ls-lisp-use-insert-directory-program buf)
+(ert-deftest dired-test-bug27243-03 ()
+  "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#61 ."
+  (let ((test-dir (make-temp-file "test-dir-" t))
+        (dired-auto-revert-buffer t)
+        test-subdir1 test-subdir2 allbufs)
     (unwind-protect
         (progn
-          (setq buf (dired (list dir "simple.el" "subr.el"))
-                size (number-to-string
-                      (file-attribute-size
-                       (file-attributes (dired-get-filename)))))
-          (search-backward-regexp size nil t)
-          (should (looking-back "[[:space:]]" (1- (point)))))
-      (when (buffer-live-p buf) (kill-buffer buf)))))
+          (with-current-buffer (find-file-noselect test-dir)
+            (push (current-buffer) allbufs)
+            (make-directory "test-subdir1")
+            (make-directory "test-subdir2")
+            (let ((test-file1 "test-file1")
+                  (test-file2 "test-file2"))
+              (with-current-buffer (find-file-noselect "test-subdir1")
+                (push (current-buffer) allbufs)
+                (write-region "Test1" nil test-file1 nil 'silent nil 'excl))
+              (with-current-buffer (find-file-noselect "test-subdir2")
+                (push (current-buffer) allbufs)
+                (write-region "Test2" nil test-file2 nil 'silent nil 'excl))))
+          ;; Call find-file with a wild card and test point in each file.
+          (let ((buffers (find-file (concat (file-name-as-directory test-dir)
+                                            "*")
+                                    t)))
+            (dolist (buf buffers)
+              (let ((pt (with-current-buffer buf (point))))
+                (switch-to-buffer (find-file-noselect test-dir))
+                (find-file (buffer-name buf))
+                (should (equal (point) pt))))
+            (append buffers allbufs)))
+      (dolist (buf allbufs)
+        (when (buffer-live-p buf) (kill-buffer buf)))
+      (delete-directory test-dir t))))
 
 (ert-deftest dired-test-bug7131 ()
   "Test for http://debbugs.gnu.org/7131 ."
@@ -152,28 +269,94 @@
           (should (cdr (dired-get-marked-files))))
       (when (buffer-live-p buf) (kill-buffer buf)))))
 
-(ert-deftest dired-test-bug27762 ()
-  "Test for http://debbugs.gnu.org/27762 ."
-  :expected-result :failed
-  (let* ((dir source-directory)
+(ert-deftest dired-test-bug27631 ()
+  "Test for http://debbugs.gnu.org/27631 ."
+  ;; For dired using 'ls' emulation we test for this bug in
+  ;; ls-lisp-tests.el and em-ls-tests.el.
+  (skip-unless (and (not (featurep 'ls-lisp))
+                    (not (featurep 'eshell))))
+  (let* ((dir (make-temp-file "bug27631" 'dir))
+         (dir1 (expand-file-name "dir1" dir))
+         (dir2 (expand-file-name "dir2" dir))
          (default-directory dir)
-         (files (mapcar (lambda (f) (concat "src/" f))
-                        (directory-files
-                         (expand-file-name "src") nil "\\.*\\.c\\'")))
-         ls-lisp-use-insert-directory-program buf)
+         buf)
     (unwind-protect
-        (let ((file1 "src/cygw32.c")
-              (file2 "src/atimer.c"))
-          (setq buf (dired (nconc (list dir) files)))
-          (dired-goto-file (expand-file-name file2 default-directory))
-          (should-not (looking-at "^   -")) ; Must be 2 spaces not 3.
-          (setq files (cons file1 (delete file1 files)))
-          (kill-buffer buf)
-          (setq buf (dired (nconc (list dir) files)))
-          (should (looking-at "src"))
-          (next-line) ; File names must be aligned.
-          (should (looking-at "src")))
+        (progn
+          (make-directory dir1)
+          (make-directory dir2)
+          (with-temp-file (expand-file-name "a.txt" dir1))
+          (with-temp-file (expand-file-name "b.txt" dir2))
+          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+          (dired-toggle-marks)
+          (should (cdr (dired-get-marked-files))))
+      (delete-directory dir 'recursive)
       (when (buffer-live-p buf) (kill-buffer buf)))))
 
+(ert-deftest dired-test-bug27899 ()
+  "Test for http://debbugs.gnu.org/27899 ."
+  (let* ((dir (expand-file-name "src" source-directory))
+         (buf (dired (list dir "cygw32.c" "alloc.c" "w32xfns.c" "xdisp.c")))
+         (orig dired-hide-details-mode))
+    (dired-goto-file (expand-file-name "cygw32.c"))
+    (forward-line 0)
+    (unwind-protect
+        (progn
+          (let ((inhibit-read-only t))
+            (dired-align-file (point) (point-max)))
+          (dired-hide-details-mode t)
+          (dired-move-to-filename)
+          (should (eq 2 (current-column))))
+      (dired-hide-details-mode orig))))
+
+(ert-deftest dired-test-bug27968 ()
+  "Test for http://debbugs.gnu.org/27968 ."
+  (let* ((top-dir (make-temp-file "top-dir" t))
+         (subdir (expand-file-name "subdir" top-dir))
+         (header-len-fn (lambda ()
+                          (save-excursion
+                            (goto-char 1)
+                            (forward-line 1)
+                            (- (point-at-eol) (point)))))
+         orig-len len diff pos line-nb)
+    (make-directory subdir 'parents)
+    (unwind-protect
+        (with-current-buffer (dired-noselect subdir)
+          (setq orig-len (funcall header-len-fn)
+                pos (point)
+                line-nb (line-number-at-pos))
+          ;; Bug arises when the header line changes its length; this may
+          ;; happen if the used space has changed: for instance, with the
+          ;; creation of additional files.
+          (make-directory "subdir" t)
+          (dired-revert)
+          ;; Change the header line.
+          (save-excursion
+            (goto-char 1)
+            (forward-line 1)
+            (let ((inhibit-read-only t)
+                  (new-header "  test-bug27968"))
+              (delete-region (point) (point-at-eol))
+              (when (= orig-len (length new-header))
+                ;; Wow lucky guy! I must buy lottery today.
+                (setq new-header (concat new-header " :-)")))
+              (insert new-header)))
+          (setq len (funcall header-len-fn)
+                diff (- len orig-len))
+          (should-not (zerop diff)) ; Header length has changed.
+          ;; If diff > 0, then the point moves back.
+          ;; If diff < 0, then the point moves forward.
+          ;; If diff = 0, then the point doesn't move.
+          ;; Sometimes this point movement causes
+          ;; line-nb != (line-number-at-pos pos), so that we get
+          ;; an unexpected file at point if we store buffer points.
+          ;; Note that the line number before/after revert
+          ;; doesn't change.
+          (should (= line-nb
+                     (line-number-at-pos)
+                     (line-number-at-pos (+ pos diff))))
+          ;; After revert, the point must be in 'subdir' line.
+          (should (equal "subdir" (dired-get-filename 'local t))))
+      (delete-directory top-dir t))))
+
 (provide 'dired-tests)
 ;; dired-tests.el ends here
diff --git a/test/lisp/emacs-lisp/cl-generic-tests.el b/test/lisp/emacs-lisp/cl-generic-tests.el
index 0768e31f7e6..31f65413c88 100644
--- a/test/lisp/emacs-lisp/cl-generic-tests.el
+++ b/test/lisp/emacs-lisp/cl-generic-tests.el
@@ -219,5 +219,29 @@
   (should (equal (cl--generic-1 '(5) nil) '("cinq" (5))))
   (should (equal (cl--generic-1 '(6) nil) '("six" a))))
 
+(cl-defgeneric cl-generic-tests--generic (x))
+(cl-defmethod cl-generic-tests--generic ((x string))
+  (message "%s is a string" x))
+(cl-defmethod cl-generic-tests--generic ((x integer))
+  (message "%s is a number" x))
+(cl-defgeneric cl-generic-tests--generic-without-methods (x y))
+(defvar cl-generic-tests--this-file
+  (file-truename (or load-file-name buffer-file-name)))
+
+(ert-deftest cl-generic-tests--method-files--finds-methods ()
+  "`method-files' returns a list of files and methods for a generic function."
+  (let ((retval (cl--generic-method-files 'cl-generic-tests--generic)))
+    (should (equal (length retval) 2))
+    (mapc (lambda (x)
+            (should (equal (car x) cl-generic-tests--this-file))
+            (should (equal (cadr x) 'cl-generic-tests--generic)))
+          retval)
+    (should-not (equal (nth 0 retval) (nth 1 retval)))))
+
+(ert-deftest cl-generic-tests--method-files--nonexistent-methods ()
+  "`method-files' returns nil if asked to find a method which doesn't exist."
+  (should-not (cl--generic-method-files 'cl-generic-tests--undefined-generic))
+  (should-not (cl--generic-method-files 'cl-generic-tests--generic-without-methods)))
+
 (provide 'cl-generic-tests)
 ;;; cl-generic-tests.el ends here
diff --git a/test/lisp/emacs-lisp/ert-tests.el b/test/lisp/emacs-lisp/ert-tests.el
index 317838b250f..57463ad932d 100644
--- a/test/lisp/emacs-lisp/ert-tests.el
+++ b/test/lisp/emacs-lisp/ert-tests.el
@@ -352,7 +352,7 @@ This macro is used to test if macroexpansion in `should' works."
   (let ((abc (ert-get-test 'ert-test-abc)))
     (should (equal (ert-test-tags abc) '(bar)))
     (should (equal (ert-test-documentation abc) "foo")))
-  (should (equal (symbol-file 'ert-test-deftest 'ert-deftest)
+  (should (equal (symbol-file 'ert-test-deftest 'ert--test)
                  (symbol-file 'ert-test--which-file 'defun)))
 
   (ert-deftest ert-test-def () :expected-result ':passed)
diff --git a/test/lisp/emacs-lisp/map-tests.el b/test/lisp/emacs-lisp/map-tests.el
index 15b0655040c..fc0a6a57c71 100644
--- a/test/lisp/emacs-lisp/map-tests.el
+++ b/test/lisp/emacs-lisp/map-tests.el
@@ -64,9 +64,11 @@ Evaluate BODY for each created map.
     (should (= 5 (map-elt map 7 5)))))
 
 (ert-deftest test-map-elt-testfn ()
-  (let ((map (list (cons "a" 1) (cons "b" 2))))
-    (should-not (map-elt map "a"))
-    (should (map-elt map "a" nil 'equal))))
+  (let ((map (list (cons "a" 1) (cons "b" 2)))
+        ;; Make sure to use a non-eq "a", even when compiled.
+        (noneq-key (string ?a)))
+    (should-not (map-elt map noneq-key))
+    (should (map-elt map noneq-key nil 'equal))))
 
 (ert-deftest test-map-elt-with-nil-value ()
   (should (null (map-elt '((a . 1)
@@ -100,10 +102,12 @@ Evaluate BODY for each created map.
                 'b))))
 
 (ert-deftest test-map-put-testfn-alist ()
-  (let ((alist (list (cons "a" 1) (cons "b" 2))))
-    (map-put alist "a" 3 'equal)
+  (let ((alist (list (cons "a" 1) (cons "b" 2)))
+        ;; Make sure to use a non-eq "a", even when compiled.
+        (noneq-key (string ?a)))
+    (map-put alist noneq-key 3 'equal)
     (should-not (cddr alist))
-    (map-put alist "a" 9)
+    (map-put alist noneq-key 9)
     (should (cddr alist))))
 
 (ert-deftest test-map-put-return-value ()
diff --git a/test/lisp/eshell/em-ls-tests.el b/test/lisp/eshell/em-ls-tests.el
new file mode 100644
index 00000000000..8e7b91d9792
--- /dev/null
+++ b/test/lisp/eshell/em-ls-tests.el
@@ -0,0 +1,98 @@
+;;; tests/em-ls-tests.el --- em-ls test suite
+
+;; Copyright (C) 2017 Free Software Foundation, Inc.
+
+;; Author: Tino Calancha <tino.calancha@gmail.com>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs 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.
+
+;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+
+;;; Code:
+
+(require 'ert)
+(require 'em-ls)
+
+(ert-deftest em-ls-test-bug27631 ()
+  "Test for http://debbugs.gnu.org/27631 ."
+  (let* ((dir (make-temp-file "bug27631" 'dir))
+         (dir1 (expand-file-name "dir1" dir))
+         (dir2 (expand-file-name "dir2" dir))
+         (default-directory dir)
+         (orig eshell-ls-use-in-dired)
+         buf)
+    (unwind-protect
+        (progn
+          (customize-set-value 'eshell-ls-use-in-dired t)
+          (make-directory dir1)
+          (make-directory dir2)
+          (with-temp-file (expand-file-name "a.txt" dir1))
+          (with-temp-file (expand-file-name "b.txt" dir2))
+          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+          (dired-toggle-marks)
+          (should (cdr (dired-get-marked-files))))
+      (customize-set-variable 'eshell-ls-use-in-dired orig)
+      (delete-directory dir 'recursive)
+      (when (buffer-live-p buf) (kill-buffer buf)))))
+
+(ert-deftest em-ls-test-bug27817 ()
+  "Test for http://debbugs.gnu.org/27817 ."
+  (let ((orig eshell-ls-use-in-dired)
+        (dired-use-ls-dired 'unspecified)
+        buf insert-directory-program)
+    (unwind-protect
+        (progn
+          (customize-set-variable 'eshell-ls-use-in-dired t)
+          (should (setq buf (dired source-directory))))
+      (customize-set-variable 'eshell-ls-use-in-dired orig)
+      (and (buffer-live-p buf) (kill-buffer)))))
+
+(ert-deftest em-ls-test-bug27843 ()
+  "Test for http://debbugs.gnu.org/27843 ."
+  (let ((orig eshell-ls-use-in-dired)
+        (dired-use-ls-dired 'unspecified)
+        buf insert-directory-program)
+    (unwind-protect
+        (progn
+          (customize-set-variable 'eshell-ls-use-in-dired t)
+          (setq buf (dired (list source-directory "lisp")))
+          (dired-toggle-marks)
+          (should-not (cdr (dired-get-marked-files))))
+      (customize-set-variable 'eshell-ls-use-in-dired orig)
+      (and (buffer-live-p buf) (kill-buffer)))))
+
+(ert-deftest em-ls-test-bug27844 ()
+  "Test for http://debbugs.gnu.org/27844 ."
+  (let ((orig eshell-ls-use-in-dired)
+        (dired-use-ls-dired 'unspecified)
+        buf insert-directory-program)
+    (unwind-protect
+        (progn
+          (customize-set-variable 'eshell-ls-use-in-dired t)
+          (setq buf (dired (expand-file-name "lisp/*.el" source-directory)))
+          (dired-toggle-marks)
+          (should (cdr (dired-get-marked-files)))
+          (kill-buffer buf)
+          (setq buf (dired (expand-file-name "lisp/subr.el" source-directory)))
+          (should (looking-at "subr\\.el")))
+      (customize-set-variable 'eshell-ls-use-in-dired orig)
+      (and (buffer-live-p buf) (kill-buffer)))))
+
+
+(provide 'em-ls-test)
+
+;;; em-ls-tests.el ends here
diff --git a/test/lisp/files-tests.el b/test/lisp/files-tests.el
index 4583b1af3c3..7bfdca53e08 100644
--- a/test/lisp/files-tests.el
+++ b/test/lisp/files-tests.el
@@ -247,10 +247,11 @@ be $HOME."
 (ert-deftest files-tests--file-name-non-special--subprocess ()
   "Check that Bug#25949 is fixed."
   (skip-unless (executable-find "true"))
-  (should (eq (let ((default-directory "/:/")) (process-file "true")) 0))
-  (should (processp (let ((default-directory "/:/"))
-                      (start-file-process "foo" nil "true"))))
-  (should (eq (let ((default-directory "/:/")) (shell-command "true")) 0)))
+  (let ((defdir (if (memq system-type '(ms-dos windows-nt)) "/:c:/" "/:/")))
+    (should (eq (let ((default-directory defdir)) (process-file "true")) 0))
+    (should (processp (let ((default-directory defdir))
+                        (start-file-process "foo" nil "true"))))
+    (should (eq (let ((default-directory defdir)) (shell-command "true")) 0))))
 
 (defmacro files-tests--with-advice (symbol where function &rest body)
   (declare (indent 3))
@@ -313,5 +314,23 @@ be invoked with the right arguments."
                       `((verify-visited-file-modtime ,buffer-visiting-file)
                         (verify-visited-file-modtime nil))))))))
 
+(ert-deftest files-tests--insert-directory-wildcard-in-dir-p ()
+  (let ((alist (list (cons "/home/user/*/.txt" (cons "/home/user/" "*/.txt"))
+                     (cons "/home/user/.txt" nil)
+                     (cons "/home/*/.txt" (cons "/home/" "*/.txt"))
+                     (cons "/home/*/" (cons "/home/" "*/"))
+                     (cons "/*/.txt" (cons "/" "*/.txt"))
+                     ;;
+                     (cons "c:/tmp/*/*.txt" (cons "c:/tmp/" "*/*.txt"))
+                     (cons "c:/tmp/*.txt" nil)
+                     (cons "c:/tmp/*/" (cons "c:/tmp/" "*/"))
+                     (cons "c:/*/*.txt" (cons "c:/" "*/*.txt")))))
+    (dolist (path-res alist)
+      (should
+       (equal
+        (cdr path-res)
+        (insert-directory-wildcard-in-dir-p (car path-res)))))))
+
+
 (provide 'files-tests)
 ;;; files-tests.el ends here
diff --git a/test/lisp/ls-lisp-tests.el b/test/lisp/ls-lisp-tests.el
new file mode 100644
index 00000000000..d24b30e5f22
--- /dev/null
+++ b/test/lisp/ls-lisp-tests.el
@@ -0,0 +1,94 @@
+;;; ls-lisp-tests.el --- tests for ls-lisp.el  -*- lexical-binding: t-*-
+
+;; Copyright (C) 2017 Free Software Foundation, Inc.
+
+;; Author: Tino Calacha <tino.calancha@gmail.com>
+;; Keywords:
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs 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.
+
+;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+
+;;; Code:
+(require 'ert)
+(require 'ls-lisp)
+
+(ert-deftest ls-lisp-unload ()
+  "Test for http://debbugs.gnu.org/xxxxx ."
+  (should (advice-member-p 'ls-lisp--insert-directory 'insert-directory))
+  (unload-feature 'ls-lisp 'force)
+  (should-not (advice-member-p 'ls-lisp--insert-directory 'insert-directory))
+  (require 'ls-lisp))
+
+(ert-deftest ls-lisp-test-bug27762 ()
+  "Test for http://debbugs.gnu.org/27762 ."
+  (let* ((dir source-directory)
+         (default-directory dir)
+         (files (mapcar (lambda (f) (concat "src/" f))
+                        (directory-files
+                         (expand-file-name "src") nil "\\.*\\.c\\'")))
+         ls-lisp-use-insert-directory-program buf)
+    (unwind-protect
+        (let ((file1 "src/cygw32.c")
+              (file2 "src/atimer.c"))
+          (setq buf (dired (nconc (list dir) files)))
+          (dired-goto-file (expand-file-name file2 default-directory))
+          (should-not (looking-at "^   -")) ; Must be 2 spaces not 3.
+          (setq files (cons file1 (delete file1 files)))
+          (kill-buffer buf)
+          (setq buf (dired (nconc (list dir) files)))
+          (should (looking-at "src"))
+          (next-line) ; File names must be aligned.
+          (should (looking-at "src")))
+      (when (buffer-live-p buf) (kill-buffer buf)))))
+
+(ert-deftest ls-lisp-test-bug27631 ()
+  "Test for http://debbugs.gnu.org/27631 ."
+  (let* ((dir (make-temp-file "bug27631" 'dir))
+         (dir1 (expand-file-name "dir1" dir))
+         (dir2 (expand-file-name "dir2" dir))
+         (default-directory dir)
+         ls-lisp-use-insert-directory-program buf)
+    (unwind-protect
+        (progn
+          (make-directory dir1)
+          (make-directory dir2)
+          (with-temp-file (expand-file-name "a.txt" dir1))
+          (with-temp-file (expand-file-name "b.txt" dir2))
+          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+          (dired-toggle-marks)
+          (should (cdr (dired-get-marked-files))))
+      (delete-directory dir 'recursive)
+      (when (buffer-live-p buf) (kill-buffer buf)))))
+
+(ert-deftest ls-lisp-test-bug27693 ()
+  "Test for http://debbugs.gnu.org/27693 ."
+  (let ((dir (expand-file-name "lisp" source-directory))
+        (size "")
+        ls-lisp-use-insert-directory-program buf)
+    (unwind-protect
+        (progn
+          (setq buf (dired (list dir "simple.el" "subr.el"))
+                size (number-to-string
+                      (file-attribute-size
+                       (file-attributes (dired-get-filename)))))
+          (search-backward-regexp size nil t)
+          (should (looking-back "[[:space:]]" (1- (point)))))
+      (when (buffer-live-p buf) (kill-buffer buf)))))
+
+(provide 'ls-lisp-tests)
+;;; ls-lisp-tests.el ends here
diff --git a/test/lisp/net/tramp-tests.el b/test/lisp/net/tramp-tests.el
index bb1bafa789f..50dfd6fac2e 100644
--- a/test/lisp/net/tramp-tests.el
+++ b/test/lisp/net/tramp-tests.el
@@ -123,9 +123,10 @@ being the result.")
   (cdr tramp--test-enabled-checked))
 
 (defun tramp--test-make-temp-name (&optional local quoted)
-  "Create a temporary file name for test.
-If LOCAL is non-nil, a local file is created.
-If QUOTED is non-nil, the local part of the file is quoted."
+  "Return a temporary file name for test.
+If LOCAL is non-nil, a local file name is returned.
+If QUOTED is non-nil, the local part of the file name is quoted.
+The temporary file is not created."
   (funcall
    (if quoted 'tramp-compat-file-name-quote 'identity)
    (expand-file-name
@@ -2201,6 +2202,110 @@ This tests also `file-directory-p' and `file-accessible-directory-p'."
         ;; Cleanup.
         (ignore-errors (delete-directory tmp-name1 'recursive))))))
 
+(ert-deftest tramp-test17-dired-with-wildcards ()
+  "Check `dired' with wildcards."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless (tramp--test-sh-p))
+  ;; Since Emacs 26.1.
+  (skip-unless (fboundp 'insert-directory-wildcard-in-dir-p))
+
+  (dolist (quoted (if tramp--test-expensive-test '(nil t) '(nil)))
+    (let* ((tmp-name1
+            (expand-file-name (tramp--test-make-temp-name nil quoted)))
+           (tmp-name2
+            (expand-file-name (tramp--test-make-temp-name nil quoted)))
+           (tmp-name3 (expand-file-name "foo" tmp-name1))
+           (tmp-name4 (expand-file-name "bar" tmp-name2))
+           (tramp-test-temporary-file-directory
+            (funcall
+             (if quoted 'tramp-compat-file-name-quote 'identity)
+             tramp-test-temporary-file-directory))
+           buffer)
+      (unwind-protect
+          (progn
+            (make-directory tmp-name1)
+            (write-region "foo" nil tmp-name3)
+            (should (file-directory-p tmp-name1))
+            (should (file-exists-p tmp-name3))
+            (make-directory tmp-name2)
+            (write-region "foo" nil tmp-name4)
+            (should (file-directory-p tmp-name2))
+            (should (file-exists-p tmp-name4))
+
+            ;; Check for expanded directory names.
+            (with-current-buffer
+                (setq buffer
+                      (dired-noselect
+                       (expand-file-name
+                        "tramp-test*" tramp-test-temporary-file-directory)))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name1 tramp-test-temporary-file-directory))))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name2 tramp-test-temporary-file-directory)))))
+            (kill-buffer buffer)
+
+            ;; Check for expanded directory and file names.
+            (with-current-buffer
+                (setq buffer
+                      (dired-noselect
+                       (expand-file-name
+                        "tramp-test*/*" tramp-test-temporary-file-directory)))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name3 tramp-test-temporary-file-directory))))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name4
+                  tramp-test-temporary-file-directory)))))
+            (kill-buffer buffer)
+
+            ;; Check for special characters.
+            (setq tmp-name3 (expand-file-name "*?" tmp-name1))
+            (setq tmp-name4 (expand-file-name "[a-z0-9]" tmp-name2))
+            (write-region "foo" nil tmp-name3)
+            (should (file-exists-p tmp-name3))
+            (write-region "foo" nil tmp-name4)
+            (should (file-exists-p tmp-name4))
+
+            (with-current-buffer
+                (setq buffer
+                      (dired-noselect
+                       (expand-file-name
+                        "tramp-test*/*" tramp-test-temporary-file-directory)))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name3 tramp-test-temporary-file-directory))))
+              (goto-char (point-min))
+              (should
+               (re-search-forward
+                (regexp-quote
+                 (file-relative-name
+                  tmp-name4
+                  tramp-test-temporary-file-directory)))))
+            (kill-buffer buffer))
+
+        ;; Cleanup.
+        (ignore-errors (kill-buffer buffer))
+        (ignore-errors (delete-directory tmp-name1 'recursive))
+        (ignore-errors (delete-directory tmp-name2 'recursive))))))
+
 (ert-deftest tramp-test18-file-attributes ()
   "Check `file-attributes'.
 This tests also `file-readable-p', `file-regular-p' and
@@ -3005,6 +3110,7 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
   :tags '(:expensive-test)
   (skip-unless (tramp--test-enabled))
   (skip-unless (tramp--test-sh-p))
+  ;; Since Emacs 26.1.
   (skip-unless (and (fboundp 'connection-local-set-profile-variables)
                     (fboundp 'connection-local-set-profiles)))
 
@@ -3214,6 +3320,7 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
 (ert-deftest tramp-test33-make-nearby-temp-file ()
   "Check `make-nearby-temp-file' and `temporary-file-directory'."
   (skip-unless (tramp--test-enabled))
+  ;; Since Emacs 26.1.
   (skip-unless
    (and (fboundp 'make-nearby-temp-file) (fboundp 'temporary-file-directory)))
 
@@ -3680,6 +3787,10 @@ Use the `ls' command."
           tramp-connection-properties)))
     (tramp--test-utf8)))
 
+(defun tramp--test-timeout-handler ()
+  (interactive)
+  (ert-fail (format "`%s' timed out" (ert-test-name (ert-running-test)))))
+
 ;; This test is inspired by Bug#16928.
 (ert-deftest tramp-test36-asynchronous-requests ()
   "Check parallel asynchronous requests.
@@ -3689,10 +3800,16 @@ process sentinels.  They shall not disturb each other."
   (skip-unless (tramp--test-enabled))
   (skip-unless (tramp--test-sh-p))
 
-  ;; This test could be blocked on hydra.
-  (with-timeout
-      (300 (ert-fail "`tramp-test36-asynchronous-requests' timed out"))
-    (let* ((tmp-name (tramp--test-make-temp-name))
+  ;; This test could be blocked on hydra.  So we set a timeout of 300
+  ;; seconds, and we send a SIGUSR1 signal after 300 seconds.
+  (with-timeout (300 (tramp--test-timeout-handler))
+    (define-key special-event-map [sigusr1] 'tramp--test-timeout-handler)
+    (tramp--test-instrument-test-case (if (getenv "EMACS_HYDRA_CI") 10 0)
+    (let* ((watchdog
+            (start-process
+             "*watchdog*" nil shell-file-name shell-command-switch
+             (format "sleep 300; kill -USR1 %d" (emacs-pid))))
+           (tmp-name (tramp--test-make-temp-name))
            (default-directory tmp-name)
            ;; Do not cache Tramp properties.
            (remote-file-name-inhibit-cache t)
@@ -3791,25 +3908,18 @@ process sentinels.  They shall not disturb each other."
                        (count (process-get proc 'bar)))
                   (tramp--test-message
                    "Start action %d %s %s" count buf (current-time-string))
-                  ;; Regular operation.
+                  ;; Regular operation prior process action.
                   (if (= count 0)
                       (should-not (file-attributes file))
                     (should (file-attributes file)))
                   ;; Send string to process.
-                  (tramp--test-message
-                   "Trace 1 action %d %s %s" count buf (current-time-string))
                   (process-send-string proc (format "%s\n" (buffer-name buf)))
-                  (tramp--test-message
-                   "Trace 2 action %d %s %s" count buf (current-time-string))
                   (accept-process-output proc 0.1 nil 0)
-                  ;; Regular operation.
-                  (tramp--test-message
-                   "Trace 3 action %d %s %s" count buf (current-time-string))
+                  ;; Give the watchdog a chance.
+                  (read-event nil nil 0.01)
+                  ;; Regular operation post process action.
                   (if (= count 2)
-                      (if (= (length buffers) 1)
-                          (tramp--test-instrument-test-case 10
-                            (should-not (file-attributes file)))
-                        (should-not (file-attributes file)))
+                      (should-not (file-attributes file))
                     (should (file-attributes file)))
                   (tramp--test-message
                    "Stop action %d %s %s" count buf (current-time-string))
@@ -3820,8 +3930,7 @@ process sentinels.  They shall not disturb each other."
             ;; Checks.  All process output shall exists in the
             ;; respective buffers.  All created files shall be
             ;; deleted.
-            (tramp--test-message
-             "Check %s" (current-time-string))
+            (tramp--test-message "Check %s" (current-time-string))
             (dolist (buf buffers)
               (with-current-buffer buf
                 (should (string-equal (format "%s\n" buf) (buffer-string)))))
@@ -3830,11 +3939,13 @@ process sentinels.  They shall not disturb each other."
               tmp-name nil directory-files-no-dot-files-regexp)))
 
         ;; Cleanup.
+        (define-key special-event-map [sigusr1] 'ignore)
+        (ignore-errors (quit-process watchdog))
         (dolist (buf buffers)
           (ignore-errors (delete-process (get-buffer-process buf)))
           (ignore-errors (kill-buffer buf)))
         (ignore-errors (cancel-timer timer))
-        (ignore-errors (delete-directory tmp-name 'recursive))))))
+        (ignore-errors (delete-directory tmp-name 'recursive)))))))
 
 (ert-deftest tramp-test37-recursive-load ()
   "Check that Tramp does not fail due to recursive load."
@@ -3911,8 +4022,8 @@ Since it unloads Tramp, it shall be the last test to run."
     (should-not (cl--find-class 'tramp-file-name))
     (mapatoms
      (lambda (x)
-       (and (string-match "tramp-file-name" (symbol-name x))
-            (functionp x)
+       (and (functionp x)
+            (string-match "tramp-file-name" (symbol-name x))
             (ert-fail (format "Structure function `%s' still exists" x)))))
     ;; There shouldn't be left a hook function containing a Tramp
     ;; function.  We do not regard the Tramp unload hooks.
diff --git a/test/lisp/register-tests.el b/test/lisp/register-tests.el
new file mode 100644
index 00000000000..0425bc0e0f4
--- /dev/null
+++ b/test/lisp/register-tests.el
@@ -0,0 +1,43 @@
+;;; register-tests.el --- tests for register.el  -*- lexical-binding: t-*-
+
+;; Copyright (C) 2017 Free Software Foundation, Inc.
+
+;; Author: Tino Calacha <tino.calancha@gmail.com>
+;; Keywords:
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs 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.
+
+;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+
+;;; Code:
+(require 'ert)
+(require 'cl-lib)
+
+(ert-deftest register-test-bug27634 ()
+  "Test for http://debbugs.gnu.org/27634 ."
+  (dolist (event (list ?\C-g 'escape ?\C-\[))
+    (cl-letf (((symbol-function 'read-key) #'ignore)
+              (last-input-event event)
+              (register-alist nil))
+      (should (equal 'quit
+                     (condition-case err
+                         (call-interactively 'point-to-register)
+                       (quit (car err)))))
+      (should-not register-alist))))
+
+(provide 'register-tests)
+;;; register-tests.el ends here
diff --git a/test/lisp/subr-tests.el b/test/lisp/subr-tests.el
index 7e50429a5bf..a59f0ca90e1 100644
--- a/test/lisp/subr-tests.el
+++ b/test/lisp/subr-tests.el
@@ -292,31 +292,6 @@ cf. Bug#25477."
   (should-error (eval '(dolist "foo") t)
                 :type 'wrong-type-argument))
 
-(require 'cl-generic)
-(cl-defgeneric subr-tests--generic (x))
-(cl-defmethod subr-tests--generic ((x string))
-  (message "%s is a string" x))
-(cl-defmethod subr-tests--generic ((x integer))
-  (message "%s is a number" x))
-(cl-defgeneric subr-tests--generic-without-methods (x y))
-(defvar subr-tests--this-file
-  (file-truename (or load-file-name buffer-file-name)))
-
-(ert-deftest subr-tests--method-files--finds-methods ()
-  "`method-files' returns a list of files and methods for a generic function."
-  (let ((retval (method-files 'subr-tests--generic)))
-    (should (equal (length retval) 2))
-    (mapc (lambda (x)
-            (should (equal (car x) subr-tests--this-file))
-            (should (equal (cadr x) 'subr-tests--generic)))
-          retval)
-    (should-not (equal (nth 0 retval) (nth 1 retval)))))
-
-(ert-deftest subr-tests--method-files--nonexistent-methods ()
-  "`method-files' returns nil if asked to find a method which doesn't exist."
-  (should-not (method-files 'subr-tests--undefined-generic))
-  (should-not (method-files 'subr-tests--generic-without-methods)))
-
 (ert-deftest subr-tests-bug22027 ()
   "Test for http://debbugs.gnu.org/22027 ."
   (let ((default "foo") res)
diff --git a/test/lisp/vc/ediff-ptch-tests.el b/test/lisp/vc/ediff-ptch-tests.el
index 387786ced06..6fbc1b0a8bd 100644
--- a/test/lisp/vc/ediff-ptch-tests.el
+++ b/test/lisp/vc/ediff-ptch-tests.el
@@ -66,41 +66,55 @@ index 6a07f80..6e8e947 100644
       (write-region nil nil bar nil 'silent))
     (call-process git-program nil `(:file ,patch) nil "diff")
     (call-process git-program nil nil nil "reset" "--hard" "HEAD")
+    ;; Visit the diff file i.e., patch; extract from it the parts
+    ;; affecting just each of the files: store in patch-bar the part
+    ;; affecting 'bar', and in patch-qux the part affecting 'qux'.
     (find-file patch)
     (unwind-protect
         (let* ((info
                 (progn (ediff-map-patch-buffer (current-buffer)) ediff-patch-map))
-               (patch1
+               (patch-bar
                 (buffer-substring-no-properties
                  (car (nth 3 (car info)))
                  (car (nth 4 (car info)))))
-               (patch2
+               (patch-qux
                 (buffer-substring-no-properties
                  (car (nth 3 (cadr info)))
                  (car (nth 4 (cadr info))))))
           ;; Apply both patches.
-          (dolist (x (list (cons patch1 bar) (cons patch2 qux)))
+          (dolist (x (list (cons patch-bar bar) (cons patch-qux qux)))
             (with-temp-buffer
-              (insert (car x))
-              (call-process-region (point-min)
-                                   (point-max)
-                                   ediff-patch-program
-                                   nil nil nil
-                                   "-b" (cdr x))))
-          ;; Check backup files were saved correctly.
+              ;; Some windows variants require the option '--binary'
+              ;; in order to 'patch' create backup files.
+              (let ((opts (format "--backup%s"
+                                  (if (memq system-type '(windows-nt ms-dos))
+                                      " --binary" ""))))
+                (insert (car x))
+                (call-process-region (point-min)
+                                     (point-max)
+                                     ediff-patch-program
+                                     nil nil nil
+                                     opts (cdr x)))))
+          ;; Check backup files were saved correctly; in Bug#26084 some
+          ;; of the backup files are overwritten with the actual content
+          ;; of the updated file.  To ensure that the bug is fixed we just
+          ;; need to check that every backup file produced has different
+          ;; content that the current updated file.
           (dolist (x (list qux bar))
             (let ((backup
                    (car
                     (directory-files
                      tmpdir 'full
                      (concat (file-name-nondirectory x) ".")))))
-              (should-not
-               (string= (with-temp-buffer
-                          (insert-file-contents x)
-                          (buffer-string))
-                        (with-temp-buffer
-                          (insert-file-contents backup)
-                          (buffer-string))))))
+              ;; Compare files only if the backup has being created.
+              (when backup
+                (should-not
+                 (string= (with-temp-buffer
+                            (insert-file-contents x)
+                            (buffer-string))
+                          (with-temp-buffer
+                            (insert-file-contents backup)
+                            (buffer-string)))))))
           (delete-directory tmpdir 'recursive)
           (delete-file patch)))))
 
diff --git a/test/src/buffer-tests.el b/test/src/buffer-tests.el
index 793dddd8bd4..87406740a78 100644
--- a/test/src/buffer-tests.el
+++ b/test/src/buffer-tests.el
@@ -45,4 +45,9 @@ with parameters from the *Messages* buffer modification."
             (should (eq buf (current-buffer))))
         (when msg-ov (delete-overlay msg-ov))))))
 
+(ert-deftest test-generate-new-buffer-name-bug27966 ()
+  (should-not (string-equal "nil"
+                            (progn (get-buffer-create "nil")
+                                   (generate-new-buffer-name "nil")))))
+
 ;;; buffer-tests.el ends here
diff --git a/test/src/eval-tests.el b/test/src/eval-tests.el
index 03f408716b1..b98de0aa65e 100644
--- a/test/src/eval-tests.el
+++ b/test/src/eval-tests.el
@@ -59,4 +59,24 @@ Bug#24912 and Bug#24913."
         (should-error (,form ,arg) :type 'wrong-type-argument))
      t)))
 
+(ert-deftest eval-tests--if-dot-string ()
+  "Check that Emacs rejects (if . \"string\")."
+  (should-error (eval '(if . "abc")) :type 'wrong-type-argument)
+  (let ((if-tail (list '(setcdr if-tail "abc") t)))
+    (should-error (eval (cons 'if if-tail))))
+  (let ((if-tail (list '(progn (setcdr if-tail "abc") nil) t)))
+    (should-error (eval (cons 'if if-tail)))))
+
+(ert-deftest eval-tests--let-with-circular-defs ()
+  "Check that Emacs reports an error for (let VARS ...) when VARS is circular."
+  (let ((vars (list 'v)))
+    (setcdr vars vars)
+    (dolist (let-sym '(let let*))
+      (should-error (eval (list let-sym vars))))))
+
+(ert-deftest eval-tests--mutating-cond ()
+  "Check that Emacs doesn't crash on a cond clause that mutates during eval."
+  (let ((clauses (list '((progn (setcdr clauses "ouch") nil)))))
+    (should-error (eval (cons 'cond clauses)))))
+
 ;;; eval-tests.el ends here