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

32 files changed, 1105 insertions, 234 deletions

diff --git a/test/Makefile.in b/test/Makefile.in
index 414eca90564..ba823ec7e32 100644
--- a/test/Makefile.in
+++ b/test/Makefile.in
@@ -136,7 +136,8 @@ endif
         $(AM_V_ELC)$(emacs) -f batch-byte-compile $<
 
 ## Save logs, and show logs for failed tests.
-WRITE_LOG = > $@ 2>&1 || { STAT=$$?; cat $@; exit $$STAT; }
+WRITE_LOG = $(if $(and ${EMACS_HYDRA_CI}, $(findstring tramp, $@)), |& tee $@, > $@ 2>&1) \
+                || { STAT=$$?; cat $@; exit $$STAT; }
 
 ifeq ($(TEST_LOAD_EL), yes)
 testloadfile = $*.el
diff --git a/test/data/emacs-module/mod-test.c b/test/data/emacs-module/mod-test.c
index eee9466c5d6..42e1c2bd4ae 100644
--- a/test/data/emacs-module/mod-test.c
+++ b/test/data/emacs-module/mod-test.c
@@ -235,6 +235,27 @@ Fmod_test_invalid_load (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
   return invalid_stored_value;
 }
 
+/* An invalid finalizer: Finalizers are run during garbage collection,
+   where Lisp code can’t be executed.  -module-assertions tests for
+   this case.  */
+
+static emacs_env *current_env;
+
+static void
+invalid_finalizer (void *ptr)
+{
+  current_env->intern (current_env, "nil");
+}
+
+static emacs_value
+Fmod_test_invalid_finalizer (emacs_env *env, ptrdiff_t nargs, emacs_value *args,
+                             void *data)
+{
+  current_env = env;
+  env->make_user_ptr (env, invalid_finalizer, NULL);
+  return env->funcall (env, env->intern (env, "garbage-collect"), 0, NULL);
+}
+
 
 /* Lisp utilities for easier readability (simple wrappers).  */
 
@@ -300,6 +321,8 @@ emacs_module_init (struct emacs_runtime *ert)
   DEFUN ("mod-test-vector-eq", Fmod_test_vector_eq, 2, 2, NULL, NULL);
   DEFUN ("mod-test-invalid-store", Fmod_test_invalid_store, 0, 0, NULL, NULL);
   DEFUN ("mod-test-invalid-load", Fmod_test_invalid_load, 0, 0, NULL, NULL);
+  DEFUN ("mod-test-invalid-finalizer", Fmod_test_invalid_finalizer, 0, 0,
+         NULL, NULL);
 
 #undef DEFUN
 
diff --git a/test/lisp/dired-tests.el b/test/lisp/dired-tests.el
index 1b814baac58..69331457c0e 100644
--- a/test/lisp/dired-tests.el
+++ b/test/lisp/dired-tests.el
@@ -21,7 +21,7 @@
 (require 'ert)
 (require 'dired)
 (require 'nadvice)
-
+(require 'ls-lisp)
 
 (ert-deftest dired-autoload ()
   "Tests to see whether dired-x has been autoloaded"
@@ -38,19 +38,21 @@
          (file      "test")
          (full-name (expand-file-name file dir))
          (regexp    "bar")
-         (dired-always-read-filesystem t))
+         (dired-always-read-filesystem t) buffers)
     (if (file-exists-p dir)
         (delete-directory dir 'recursive))
     (make-directory dir)
     (with-temp-file full-name (insert "foo"))
-    (find-file-noselect full-name)
-    (dired dir)
+    (push (find-file-noselect full-name) buffers)
+    (push (dired dir) buffers)
     (with-temp-file full-name (insert "bar"))
     (dired-mark-files-containing-regexp regexp)
     (unwind-protect
         (should (equal (dired-get-marked-files nil nil nil 'distinguish-1-mark)
                        `(t ,full-name)))
       ;; Clean up
+      (dolist (buf buffers)
+        (when (buffer-live-p buf) (kill-buffer buf)))
       (delete-directory dir 'recursive))))
 
 (ert-deftest dired-test-bug25609 ()
@@ -60,7 +62,8 @@
          (target (expand-file-name (file-name-nondirectory from) to))
          (nested (expand-file-name (file-name-nondirectory from) target))
          (dired-dwim-target t)
-         (dired-recursive-copies 'always)) ; Don't prompt me.
+         (dired-recursive-copies 'always) ; Don't prompt me.
+         buffers)
     (advice-add 'dired-query ; Don't ask confirmation to overwrite a file.
                 :override
                 (lambda (_sym _prompt &rest _args) (setq dired-query t))
@@ -70,8 +73,8 @@
                 (lambda (_prompt _coll &optional _pred _match init _hist _def _inherit _keymap)
                   init)
                 '((name . "advice-completing-read")))
-    (dired to)
-    (dired-other-window temporary-file-directory)
+    (push (dired to) buffers)
+    (push (dired-other-window temporary-file-directory) buffers)
     (dired-goto-file from)
     (dired-do-copy)
     (dired-do-copy); Again.
@@ -79,10 +82,98 @@
         (progn
           (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)
       (delete-directory to 'recursive)
       (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 ."
+  (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-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)))))
+
+(ert-deftest dired-test-bug7131 ()
+  "Test for http://debbugs.gnu.org/7131 ."
+  (let* ((dir (expand-file-name "lisp" source-directory))
+         (buf (dired dir)))
+    (unwind-protect
+        (progn
+          (setq buf (dired (list dir "simple.el")))
+          (dired-toggle-marks)
+          (should-not (cdr (dired-get-marked-files)))
+          (kill-buffer buf)
+          (setq buf (dired (list dir "simple.el"))
+                buf (dired dir))
+          (dired-toggle-marks)
+          (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)
+         (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)))))
+
 (provide 'dired-tests)
 ;; dired-tests.el ends here
diff --git a/test/lisp/electric-tests.el b/test/lisp/electric-tests.el
index c4ccec7a0d8..c6ffccc0794 100644
--- a/test/lisp/electric-tests.el
+++ b/test/lisp/electric-tests.el
@@ -694,6 +694,8 @@ baz\"\""
   :bindings '((electric-quote-context-sensitive . t))
   :test-in-comments nil :test-in-strings nil)
 
+;; Simulate ‘markdown-mode’: it sets both ‘comment-start’ and
+;; ‘comment-use-syntax’, but derives from ‘text-mode’.
 (define-electric-pair-test electric-quote-markdown-in-text
   "" "'" :expected-string "’" :expected-point 2
   :modes '(text-mode)
@@ -703,6 +705,7 @@ baz\"\""
                           (lambda ()
                             (save-excursion (search-backward "`" nil t)))
                           nil :local))
+  :bindings '((comment-start . "<!--") (comment-use-syntax . t))
   :test-in-comments nil :test-in-strings nil)
 
 (define-electric-pair-test electric-quote-markdown-in-code
@@ -714,6 +717,7 @@ baz\"\""
                           (lambda ()
                             (save-excursion (search-backward "`" nil t)))
                           nil :local))
+  :bindings '((comment-start . "<!--") (comment-use-syntax . t))
   :test-in-comments nil :test-in-strings nil)
 
 (provide 'electric-tests)
diff --git a/test/lisp/emacs-lisp/eieio-tests/eieio-test-methodinvoke.el b/test/lisp/emacs-lisp/eieio-tests/eieio-test-methodinvoke.el
index 241ca65122d..3df2157cc83 100644
--- a/test/lisp/emacs-lisp/eieio-tests/eieio-test-methodinvoke.el
+++ b/test/lisp/emacs-lisp/eieio-tests/eieio-test-methodinvoke.el
@@ -192,7 +192,7 @@
 (ert-deftest eieio-test-method-order-list-6 ()
   ;; FIXME repeated intermittent failures on hydra (bug#24503)
   ;; ((:STATIC C) (:STATIC C-base1) (:STATIC C-base2)) != ((:STATIC C))")
-  (skip-unless (not (getenv "NIX_STORE")))
+  (skip-unless (not (getenv "EMACS_HYDRA_CI")))
   (let ((eieio-test-method-order-list nil)
         (ans '(
                (:STATIC C)
diff --git a/test/lisp/emacs-lisp/eieio-tests/eieio-tests.el b/test/lisp/emacs-lisp/eieio-tests/eieio-tests.el
index c34560ab585..1a6ab9da085 100644
--- a/test/lisp/emacs-lisp/eieio-tests/eieio-tests.el
+++ b/test/lisp/emacs-lisp/eieio-tests/eieio-tests.el
@@ -894,7 +894,7 @@ Subclasses to override slot attributes.")
 
 (ert-deftest eieio-test-37-obsolete-name-in-constructor ()
   ;; FIXME repeated intermittent failures on hydra (bug#24503)
-  (skip-unless (not (getenv "NIX_STORE")))
+  (skip-unless (not (getenv "EMACS_HYDRA_CI")))
   (should (equal (eieio--testing "toto") '("toto" 2))))
 
 (ert-deftest eieio-autoload ()
diff --git a/test/lisp/emacs-lisp/map-tests.el b/test/lisp/emacs-lisp/map-tests.el
index 07e85cc5391..15b0655040c 100644
--- a/test/lisp/emacs-lisp/map-tests.el
+++ b/test/lisp/emacs-lisp/map-tests.el
@@ -63,6 +63,11 @@ Evaluate BODY for each created map.
   (with-maps-do 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))))
+
 (ert-deftest test-map-elt-with-nil-value ()
   (should (null (map-elt '((a . 1)
                            (b))
@@ -94,6 +99,13 @@ Evaluate BODY for each created map.
     (should (eq (map-elt alist 2)
                 'b))))
 
+(ert-deftest test-map-put-testfn-alist ()
+  (let ((alist (list (cons "a" 1) (cons "b" 2))))
+    (map-put alist "a" 3 'equal)
+    (should-not (cddr alist))
+    (map-put alist "a" 9)
+    (should (cddr alist))))
+
 (ert-deftest test-map-put-return-value ()
   (let ((ht (make-hash-table)))
     (should (eq (map-put ht 'a 'hello) 'hello))))
diff --git a/test/lisp/emacs-lisp/rx-tests.el b/test/lisp/emacs-lisp/rx-tests.el
index 8b7945c9d27..8f353b7e863 100644
--- a/test/lisp/emacs-lisp/rx-tests.el
+++ b/test/lisp/emacs-lisp/rx-tests.el
@@ -33,5 +33,15 @@
                                   (number-sequence ?< ?\])
                                   (number-sequence ?- ?:))))))
 
+(ert-deftest rx-pcase ()
+  (should (equal (pcase "a 1 2 3 1 1 b"
+                   ((rx (let u (+ digit)) space
+                        (let v (+ digit)) space
+                        (let v (+ digit)) space
+                        (backref u) space
+                        (backref 1))
+                    (list u v)))
+                 '("1" "3"))))
+
 (provide 'rx-tests)
 ;; rx-tests.el ends here.
diff --git a/test/lisp/filenotify-tests.el b/test/lisp/filenotify-tests.el
index 8d05ceacee2..3456d31fda9 100644
--- a/test/lisp/filenotify-tests.el
+++ b/test/lisp/filenotify-tests.el
@@ -173,8 +173,8 @@ Return nil when any other file notification watch is still active."
       tramp-verbose 0
       tramp-message-show-message nil)
 
-;; This shall happen on hydra only.
-(when (getenv "NIX_STORE")
+;; This should happen on hydra only.
+(when (getenv "EMACS_HYDRA_CI")
   (add-to-list 'tramp-remote-path 'tramp-own-remote-path))
 
 ;; We do not want to try and fail `file-notify-add-watch'.
diff --git a/test/lisp/ibuffer-tests.el b/test/lisp/ibuffer-tests.el
index b9f7fe7cde8..af75aa0ec7f 100644
--- a/test/lisp/ibuffer-tests.el
+++ b/test/lisp/ibuffer-tests.el
@@ -32,7 +32,7 @@
 (declare-function ibuffer-format-qualifier "ibuf-ext" (qualifier))
 (declare-function ibuffer-unary-operand "ibuf-ext" (filter))
 
-(ert-deftest ibuffer-autoload ()
+(ert-deftest ibuffer-0autoload ()       ; sort first
   "Tests to see whether ibuffer has been autoloaded"
   (skip-unless (not (featurep 'ibuf-ext)))
   (should
@@ -76,7 +76,7 @@
 
 (ert-deftest ibuffer-save-filters ()
   "Tests that `ibuffer-save-filters' saves in the proper format."
-  (skip-unless (featurep 'ibuf-ext))
+  (require 'ibuf-ext)
   (let ((ibuffer-save-with-custom nil)
         (ibuffer-saved-filters nil)
         (test1 '((mode . org-mode)
@@ -150,6 +150,7 @@
 
 ;; Test Filter Inclusion
 (let* (test-buffer-list  ; accumulated buffers to clean up
+       test-file-list
        ;; Utility functions without polluting the environment
        (set-buffer-mode
         (lambda (buffer mode)
@@ -192,6 +193,7 @@
                  (file    (make-temp-file prefix nil suffix))
                  (buf     (find-file-noselect file t)))
             (push buf test-buffer-list) ; record for cleanup
+            (push file test-file-list)
             (funcall set-buffer-mode buf mode)
             (funcall set-buffer-contents buf size include)
             buf)))
@@ -213,6 +215,8 @@
        (clean-up
         (lambda ()
           "Restore all emacs state modified during the tests"
+          (dolist (f test-file-list)
+            (and f (file-exists-p f) (delete-file f)))
           (while test-buffer-list       ; created temporary buffers
             (let ((buf (pop test-buffer-list)))
               (with-current-buffer buf (bury-buffer)) ; ensure not selected
@@ -220,7 +224,7 @@
   ;; Tests
   (ert-deftest ibuffer-filter-inclusion-1 ()
     "Tests inclusion using basic filter combinators with a single buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-file-buffer "ibuf-test-1" :size 100
@@ -263,7 +267,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-2 ()
     "Tests inclusion of basic filters in combination on a single buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-file-buffer "ibuf-test-2" :size 200
@@ -298,7 +302,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-3 ()
     "Tests inclusion with filename filters on specified buffers."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let* ((bufA
                 (funcall create-file-buffer "ibuf-test-3.a" :size 50
@@ -332,7 +336,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-4 ()
     "Tests inclusion with various filters on a single buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-file-buffer "ibuf-test-4"
@@ -366,7 +370,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-5 ()
     "Tests inclusion with various filters on a single buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-non-file-buffer "ibuf-test-5.el"
@@ -392,7 +396,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-6 ()
     "Tests inclusion using saved filters and DeMorgan's laws."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-non-file-buffer "*ibuf-test-6*" :size 65
@@ -425,7 +429,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-7 ()
     "Tests inclusion with various filters on a single buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((buf
                (funcall create-non-file-buffer "ibuf-test-7"
@@ -446,7 +450,7 @@
 
   (ert-deftest ibuffer-filter-inclusion-8 ()
     "Tests inclusion with various filters."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((bufA
                (funcall create-non-file-buffer "ibuf-test-8a"
@@ -534,7 +538,7 @@
   ;; Tests
   (ert-deftest ibuffer-decompose-filter ()
     "Tests `ibuffer-decompose-filter' for and, or, not, and saved."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((ibuf (funcall get-test-ibuffer)))
           (with-current-buffer ibuf
@@ -583,7 +587,7 @@
 
   (ert-deftest ibuffer-and-filter ()
     "Tests `ibuffer-and-filter' in an Ibuffer buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((ibuf (funcall get-test-ibuffer)))
           (with-current-buffer ibuf
@@ -660,7 +664,7 @@
 
   (ert-deftest ibuffer-or-filter ()
     "Tests `ibuffer-or-filter' in an Ibuffer buffer."
-    (skip-unless (featurep 'ibuf-ext))
+    (require 'ibuf-ext)
     (unwind-protect
         (let ((ibuf (funcall get-test-ibuffer)))
           (with-current-buffer ibuf
@@ -737,7 +741,7 @@
 
 (ert-deftest ibuffer-format-qualifier ()
   "Tests string recommendation of filter from `ibuffer-format-qualifier'."
-  (skip-unless (featurep 'ibuf-ext))
+  (require 'ibuf-ext)
   (let ((test1 '(mode . org-mode))
         (test2 '(size-lt . 100))
         (test3 '(derived-mode . prog-mode))
@@ -802,7 +806,7 @@
 
 (ert-deftest ibuffer-unary-operand ()
   "Tests `ibuffer-unary-operand': (not cell) or (not . cell) -> cell."
-  (skip-unless (featurep 'ibuf-ext))
+  (require 'ibuf-ext)
   (should (equal (ibuffer-unary-operand '(not . (mode "foo")))
                  '(mode "foo")))
   (should (equal (ibuffer-unary-operand '(not (mode "foo")))
diff --git a/test/lisp/international/ucs-normalize-tests.el b/test/lisp/international/ucs-normalize-tests.el
index d85efe2d7bf..02a4bba7a5f 100644
--- a/test/lisp/international/ucs-normalize-tests.el
+++ b/test/lisp/international/ucs-normalize-tests.el
@@ -26,15 +26,13 @@
 ;; If there are lines marked as failing (see
 ;; `ucs-normalize-tests--failing-lines-part1' and
 ;; `ucs-normalize-tests--failing-lines-part2'), they may need to be
-;; adjusted when NormalizationTest.txt is updated.  To get a list of
-;; currently failing lines, set those 2 variables to nil, run the
-;; tests, and inspect the values of
-;; `ucs-normalize-tests--part1-rule1-failed-lines' and
-;; `ucs-normalize-tests--part1-rule2-failed-chars', respectively.
+;; adjusted when NormalizationTest.txt is updated.  Run the function
+;; `ucs-normalize-check-failing-lines' to see what changes are needed.
 
 ;;; Code:
 
 (eval-when-compile (require 'cl-lib))
+(require 'seq)
 (require 'ert)
 (require 'ucs-normalize)
 
@@ -44,83 +42,98 @@
 (defun ucs-normalize-tests--parse-column ()
   (let ((chars nil)
         (term nil))
-    (while (and (not (equal term ";"))
+    (while (and (not (eq term ?\;))
                 (looking-at "\\([[:xdigit:]]\\{4,6\\}\\)\\([; ]\\)"))
-      (let ((code-point (match-string 1)))
-        (setq term (match-string 2))
+      (let ((code-point (match-string-no-properties 1)))
+        (setq term (char-after (match-beginning 2)))
         (goto-char (match-end 0))
         (push (string-to-number code-point 16) chars)))
-    (nreverse chars)))
+    (apply #'string (nreverse chars))))
 
-(defmacro ucs-normalize-tests--normalize (norm str)
+(defconst ucs-normalize-tests--norm-buf (generate-new-buffer " *ucs-normalizing-buffer*"))
+
+(defmacro ucs-normalize-tests--normalization-equal-p (norm str equal-to)
   "Like `ucs-normalize-string' but reuse current buffer for efficiency.
 And NORM is one of the symbols `NFC', `NFD', `NFKC', `NFKD' for brevity."
   (let ((norm-alist '((NFC . ucs-normalize-NFC-region)
                       (NFD . ucs-normalize-NFD-region)
                       (NFKC . ucs-normalize-NFKC-region)
                       (NFKD . ucs-normalize-NFKD-region))))
-    `(save-restriction
-       (narrow-to-region (point) (point))
+    `(with-current-buffer ucs-normalize-tests--norm-buf
+       (erase-buffer)
        (insert ,str)
-       (funcall #',(cdr (assq norm norm-alist)) (point-min) (point-max))
-       (delete-and-extract-region (point-min) (point-max)))))
+       (,(cdr (assq norm norm-alist)) (point-min) (point-max))
+       (goto-char (point-min))
+       (insert ,equal-to)
+       (eq (compare-buffer-substrings nil nil (point) nil (point) nil) 0))))
+
+(defmacro ucs-normalize-tests--normalization-chareq-p (norm char char-eq-to)
+  "Like `ucs-normalize-string' but reuse current buffer for efficiency.
+And NORM is one of the symbols `NFC', `NFD', `NFKC', `NFKD' for brevity."
+  (let ((norm-alist '((NFC . ucs-normalize-NFC-region)
+                      (NFD . ucs-normalize-NFD-region)
+                      (NFKC . ucs-normalize-NFKC-region)
+                      (NFKD . ucs-normalize-NFKD-region))))
+    `(with-current-buffer ucs-normalize-tests--norm-buf
+       (erase-buffer)
+       (insert ,char)
+       (,(cdr (assq norm norm-alist)) (point-min) (point-max))
+       (and (eq (buffer-size) 1)
+            (eq (char-after (point-min)) ,char-eq-to)))))
 
 (defvar ucs-normalize-tests--chars-part1 nil)
 
-(defun ucs-normalize-tests--invariants-hold-p (&rest columns)
+(defsubst ucs-normalize-tests--rule1-holds-p (source nfc nfd nfkc nfkd)
   "Check 1st conformance rule.
 The following invariants must be true for all conformant implementations..."
   (when ucs-normalize-tests--chars-part1
-    ;; See `ucs-normalize-tests--invariants-rule2-hold-p'.
+    ;; See `ucs-normalize-tests--rule2-holds-p'.
     (aset ucs-normalize-tests--chars-part1
-          (caar columns) 1))
-  (cl-destructuring-bind (source nfc nfd nfkc nfkd)
-      (mapcar (lambda (c) (apply #'string c)) columns)
-    (and
-     ;; c2 ==  toNFC(c1) ==  toNFC(c2) ==  toNFC(c3)
-     (equal nfc (ucs-normalize-tests--normalize NFC source))
-     (equal nfc (ucs-normalize-tests--normalize NFC nfc))
-     (equal nfc (ucs-normalize-tests--normalize NFC nfd))
-     ;; c4 ==  toNFC(c4) ==  toNFC(c5)
-     (equal nfkc (ucs-normalize-tests--normalize NFC nfkc))
-     (equal nfkc (ucs-normalize-tests--normalize NFC nfkd))
-
-     ;; c3 ==  toNFD(c1) ==  toNFD(c2) ==  toNFD(c3)
-     (equal nfd (ucs-normalize-tests--normalize NFD source))
-     (equal nfd (ucs-normalize-tests--normalize NFD nfc))
-     (equal nfd (ucs-normalize-tests--normalize NFD nfd))
-     ;; c5 ==  toNFD(c4) ==  toNFD(c5)
-     (equal nfkd (ucs-normalize-tests--normalize NFD nfkc))
-     (equal nfkd (ucs-normalize-tests--normalize NFD nfkd))
-
-     ;; c4 == toNFKC(c1) == toNFKC(c2) == toNFKC(c3) == toNFKC(c4) == toNFKC(c5)
-     (equal nfkc (ucs-normalize-tests--normalize NFKC source))
-     (equal nfkc (ucs-normalize-tests--normalize NFKC nfc))
-     (equal nfkc (ucs-normalize-tests--normalize NFKC nfd))
-     (equal nfkc (ucs-normalize-tests--normalize NFKC nfkc))
-     (equal nfkc (ucs-normalize-tests--normalize NFKC nfkd))
-
-     ;; c5 == toNFKD(c1) == toNFKD(c2) == toNFKD(c3) == toNFKD(c4) == toNFKD(c5)
-     (equal nfkd (ucs-normalize-tests--normalize NFKD source))
-     (equal nfkd (ucs-normalize-tests--normalize NFKD nfc))
-     (equal nfkd (ucs-normalize-tests--normalize NFKD nfd))
-     (equal nfkd (ucs-normalize-tests--normalize NFKD nfkc))
-     (equal nfkd (ucs-normalize-tests--normalize NFKD nfkd)))))
-
-(defun ucs-normalize-tests--invariants-rule2-hold-p (char)
+          (aref source 0) 1))
+  (and
+   ;; c2 ==  toNFC(c1) ==  toNFC(c2) ==  toNFC(c3)
+   (ucs-normalize-tests--normalization-equal-p NFC source nfc)
+   (ucs-normalize-tests--normalization-equal-p NFC nfc nfc)
+   (ucs-normalize-tests--normalization-equal-p NFC nfd nfc)
+   ;; c4 ==  toNFC(c4) ==  toNFC(c5)
+   (ucs-normalize-tests--normalization-equal-p NFC nfkc nfkc)
+   (ucs-normalize-tests--normalization-equal-p NFC nfkd nfkc)
+
+   ;; c3 ==  toNFD(c1) ==  toNFD(c2) ==  toNFD(c3)
+   (ucs-normalize-tests--normalization-equal-p NFD source nfd)
+   (ucs-normalize-tests--normalization-equal-p NFD nfc nfd)
+   (ucs-normalize-tests--normalization-equal-p NFD nfd nfd)
+   ;; c5 ==  toNFD(c4) ==  toNFD(c5)
+   (ucs-normalize-tests--normalization-equal-p NFD nfkc nfkd)
+   (ucs-normalize-tests--normalization-equal-p NFD nfkd nfkd)
+
+   ;; c4 == toNFKC(c1) == toNFKC(c2) == toNFKC(c3) == toNFKC(c4) == toNFKC(c5)
+   (ucs-normalize-tests--normalization-equal-p NFKC source nfkc)
+   (ucs-normalize-tests--normalization-equal-p NFKC nfc nfkc)
+   (ucs-normalize-tests--normalization-equal-p NFKC nfd nfkc)
+   (ucs-normalize-tests--normalization-equal-p NFKC nfkc nfkc)
+   (ucs-normalize-tests--normalization-equal-p NFKC nfkd nfkc)
+
+   ;; c5 == toNFKD(c1) == toNFKD(c2) == toNFKD(c3) == toNFKD(c4) == toNFKD(c5)
+   (ucs-normalize-tests--normalization-equal-p NFKD source nfkd)
+   (ucs-normalize-tests--normalization-equal-p NFKD nfc nfkd)
+   (ucs-normalize-tests--normalization-equal-p NFKD nfd nfkd)
+   (ucs-normalize-tests--normalization-equal-p NFKD nfkc nfkd)
+   (ucs-normalize-tests--normalization-equal-p NFKD nfkd nfkd)))
+
+(defsubst ucs-normalize-tests--rule2-holds-p (X)
  "Check 2nd conformance rule.
 For every code point X assigned in this version of Unicode that is not specifically
 listed in Part 1, the following invariants must be true for all conformant
 implementations:
 
   X == toNFC(X) == toNFD(X) == toNFKC(X) == toNFKD(X)"
- (let ((X (string char)))
-   (and (equal X (ucs-normalize-tests--normalize NFC X))
-        (equal X (ucs-normalize-tests--normalize NFD X))
-        (equal X (ucs-normalize-tests--normalize NFKC X))
-        (equal X (ucs-normalize-tests--normalize NFKD X)))))
+ (and (ucs-normalize-tests--normalization-chareq-p NFC X X)
+      (ucs-normalize-tests--normalization-chareq-p NFD X X)
+      (ucs-normalize-tests--normalization-chareq-p NFKC X X)
+      (ucs-normalize-tests--normalization-chareq-p NFKD X X)))
 
-(cl-defun ucs-normalize-tests--invariants-failing-for-part (part &optional skip-lines &key progress-str)
+(cl-defun ucs-normalize-tests--rule1-failing-for-partX (part &optional skip-lines &key progress-str)
   "Returns a list of failed line numbers."
   (with-temp-buffer
     (insert-file-contents ucs-normalize-test-data-file)
@@ -136,8 +149,8 @@ implementations:
                                                  progress-str beg-line end-line
                                                  0 nil 0.5))
                for line from beg-line to (1- end-line)
-               unless (or (= (following-char) ?#)
-                          (ucs-normalize-tests--invariants-hold-p
+               unless (or (eq (following-char) ?#)
+                          (ucs-normalize-tests--rule1-holds-p
                            (ucs-normalize-tests--parse-column)
                            (ucs-normalize-tests--parse-column)
                            (ucs-normalize-tests--parse-column)
@@ -148,7 +161,7 @@ implementations:
                do (forward-line)
                if reporter do (progress-reporter-update reporter line)))))
 
-(defun ucs-normalize-tests--invariants-failing-for-lines (lines)
+(defun ucs-normalize-tests--rule1-failing-for-lines (lines)
   "Returns a list of failed line numbers."
   (with-temp-buffer
     (insert-file-contents ucs-normalize-test-data-file)
@@ -156,7 +169,7 @@ implementations:
     (cl-loop for prev-line = 1 then line
              for line in lines
              do (forward-line (- line prev-line))
-             unless (ucs-normalize-tests--invariants-hold-p
+             unless (ucs-normalize-tests--rule1-holds-p
                      (ucs-normalize-tests--parse-column)
                      (ucs-normalize-tests--parse-column)
                      (ucs-normalize-tests--parse-column)
@@ -165,7 +178,7 @@ implementations:
              collect line)))
 
 (ert-deftest ucs-normalize-part0 ()
-  (should-not (ucs-normalize-tests--invariants-failing-for-part 0)))
+  (should-not (ucs-normalize-tests--rule1-failing-for-partX 0)))
 
 (defconst ucs-normalize-tests--failing-lines-part1
   (list 15131 15132 15133 15134 15135 15136 15137 15138
@@ -195,6 +208,8 @@ implementations:
   "A list of line numbers.")
 (defvar ucs-normalize-tests--part1-rule2-failed-chars nil
   "A list of code points.")
+(defvar ucs-normalize-tests--part2-rule1-failed-lines nil
+  "A list of line numbers.")
 
 (defun ucs-normalize-tests--part1-rule2 (chars-part1)
   (let ((reporter (make-progress-reporter "UCS Normalize Test Part1, rule 2"
@@ -204,11 +219,11 @@ implementations:
      (lambda (char-range listed-in-part)
        (unless (eq listed-in-part 1)
          (if (characterp char-range)
-             (progn (unless (ucs-normalize-tests--invariants-rule2-hold-p char-range)
+             (progn (unless (ucs-normalize-tests--rule2-holds-p char-range)
                       (push char-range failed-chars))
                     (progress-reporter-update reporter char-range))
            (cl-loop for char from (car char-range) to (cdr char-range)
-                    unless (ucs-normalize-tests--invariants-rule2-hold-p char)
+                    unless (ucs-normalize-tests--rule2-holds-p char)
                     do (push char failed-chars)
                     do (progress-reporter-update reporter char)))))
      chars-part1)
@@ -219,59 +234,103 @@ implementations:
   :tags '(:expensive-test)
   ;; This takes a long time, so make sure we're compiled.
   (dolist (fun '(ucs-normalize-tests--part1-rule2
-                 ucs-normalize-tests--invariants-failing-for-part
-                 ucs-normalize-tests--invariants-hold-p
-                 ucs-normalize-tests--invariants-rule2-hold-p))
+                 ucs-normalize-tests--rule1-failing-for-partX
+                 ucs-normalize-tests--rule1-holds-p
+                 ucs-normalize-tests--rule2-holds-p))
     (or (byte-code-function-p (symbol-function fun))
         (byte-compile fun)))
   (let ((ucs-normalize-tests--chars-part1 (make-char-table 'ucs-normalize-tests t)))
-    (should-not
-     (setq ucs-normalize-tests--part1-rule1-failed-lines
-           (ucs-normalize-tests--invariants-failing-for-part
-            1 ucs-normalize-tests--failing-lines-part1
-            :progress-str "UCS Normalize Test Part1, rule 1")))
-    (should-not (setq ucs-normalize-tests--part1-rule2-failed-chars
-                      (ucs-normalize-tests--part1-rule2
-                       ucs-normalize-tests--chars-part1)))))
+    (setq ucs-normalize-tests--part1-rule1-failed-lines
+          (ucs-normalize-tests--rule1-failing-for-partX
+           1 ucs-normalize-tests--failing-lines-part1
+           :progress-str "UCS Normalize Test Part1, rule 1"))
+    (setq ucs-normalize-tests--part1-rule2-failed-chars
+          (ucs-normalize-tests--part1-rule2
+           ucs-normalize-tests--chars-part1))
+    (should-not ucs-normalize-tests--part1-rule1-failed-lines)
+    (should-not ucs-normalize-tests--part1-rule2-failed-chars)))
 
 (ert-deftest ucs-normalize-part1-failing ()
   :expected-result :failed
   (skip-unless ucs-normalize-tests--failing-lines-part1)
   (should-not
-   (ucs-normalize-tests--invariants-failing-for-lines
+   (ucs-normalize-tests--rule1-failing-for-lines
     ucs-normalize-tests--failing-lines-part1)))
 
 (defconst ucs-normalize-tests--failing-lines-part2
-  (list 18328 18330 18332 18334 18336 18338 18340 18342
-        18344 18346 18348 18350 18352 18354 18356 18358
-        18360 18362 18364 18366 18368 18370 18372 18374
-        18376 18378 18380 18382 18384 18386 18388 18390
-        18392 18394 18396 18398 18400 18402 18404 18406
-        18408 18410 18412 18414 18416 18418 18420 18422
-        18424 18426 18494 18496 18498 18500 18502 18504
-        18506 18508 18510 18512 18514 18516 18518 18520
-        18522 18524 18526 18528 18530 18532 18534 18536
-        18538 18540 18542 18544 18546 18548 18550 18552
-        18554 18556 18558 18560 18562 18564 18566 18568
-        18570 18572 18574 18576 18578 18580 18582 18584
-        18586 18588 18590 18592 18594 18596))
+  (list 17656 17658 18006 18007 18008 18009 18010 18011
+        18012 18340 18342 18344 18346 18348 18350 18352
+        18354 18356 18358 18360 18362 18364 18366 18368
+        18370 18372 18374 18376 18378 18380 18382 18384
+        18386 18388 18390 18392 18394 18396 18398 18400
+        18402 18404 18406 18408 18410 18412 18414 18416
+        18418 18420 18422 18424 18426 18428 18430 18432
+        18434 18436 18438 18440 18442 18444 18446 18448
+        18450 18518 18520 18522 18524 18526 18528 18530
+        18532 18534 18536 18538 18540 18542 18544 18546
+        18548 18550 18552 18554 18556 18558 18560 18562
+        18564 18566 18568 18570 18572 18574 18576 18578
+        18580 18582 18584 18586 18588 18590 18592 18594
+        18596 18598 18600 18602 18604 18606 18608 18610
+        18612 18614 18616 18618 18620))
 
 (ert-deftest ucs-normalize-part2 ()
   :tags '(:expensive-test)
   (should-not
-   (ucs-normalize-tests--invariants-failing-for-part
-    2 ucs-normalize-tests--failing-lines-part2
-    :progress-str "UCS Normalize Test Part2")))
+   (setq ucs-normalize-tests--part2-rule1-failed-lines
+         (ucs-normalize-tests--rule1-failing-for-partX
+          2 ucs-normalize-tests--failing-lines-part2
+          :progress-str "UCS Normalize Test Part2"))))
 
 (ert-deftest ucs-normalize-part2-failing ()
   :expected-result :failed
   (skip-unless ucs-normalize-tests--failing-lines-part2)
   (should-not
-   (ucs-normalize-tests--invariants-failing-for-lines
+   (ucs-normalize-tests--rule1-failing-for-lines
     ucs-normalize-tests--failing-lines-part2)))
 
 (ert-deftest ucs-normalize-part3 ()
   (should-not
-   (ucs-normalize-tests--invariants-failing-for-part 3)))
+   (ucs-normalize-tests--rule1-failing-for-partX 3)))
+
+(defun ucs-normalize-tests--insert-failing-lines (var newval)
+  (insert (format "`%s' should be updated to:\n
+\(defconst %s
+  (list " var var))
+  (dolist (linos (seq-partition newval 8))
+    (insert (mapconcat #'number-to-string linos " ") "\n"))
+  (insert ")\)"))
+
+(defun ucs-normalize-check-failing-lines ()
+  (interactive)
+  (let ((ucs-normalize-tests--failing-lines-part1 nil)
+        (ucs-normalize-tests--failing-lines-part2 nil))
+    (setq ucs-normalize-tests--part1-rule1-failed-lines nil)
+    (setq ucs-normalize-tests--part1-rule2-failed-chars nil)
+    (setq ucs-normalize-tests--part2-rule1-failed-lines nil)
+    (ert "\\`ucs-normalize"))
+
+  (with-current-buffer (get-buffer-create "*ucs normalize change bad lines*")
+    (erase-buffer)
+    (unless (equal ucs-normalize-tests--part1-rule1-failed-lines
+                   ucs-normalize-tests--failing-lines-part1)
+      (ucs-normalize-tests--insert-failing-lines
+       'ucs-normalize-tests--failing-lines-part1
+       ucs-normalize-tests--part1-rule1-failed-lines))
+
+    (when ucs-normalize-tests--part1-rule2-failed-chars
+      (insert (format "Some characters failed rule 2!\n\n%S"
+                      `(list ,@ucs-normalize-tests--part1-rule2-failed-chars))))
+
+    (unless (equal ucs-normalize-tests--part2-rule1-failed-lines
+                   ucs-normalize-tests--failing-lines-part2)
+      (ucs-normalize-tests--insert-failing-lines
+       'ucs-normalize-tests--failing-lines-part2
+       ucs-normalize-tests--part2-rule1-failed-lines))
+    (if (> (buffer-size) 0)
+        (if noninteractive
+            (princ (buffer-string) standard-output)
+          (display-buffer (current-buffer)))
+      (message "No changes to failing lines needed"))))
 
 ;;; ucs-normalize-tests.el ends here
diff --git a/test/lisp/net/gnutls-tests.el b/test/lisp/net/gnutls-tests.el
new file mode 100644
index 00000000000..9dbb6c05b9e
--- /dev/null
+++ b/test/lisp/net/gnutls-tests.el
@@ -0,0 +1,295 @@
+;;; gnutls-tests.el --- Test suite for gnutls.el
+
+;; Copyright (C) 2017 Free Software Foundation, Inc.
+
+;; Author: Ted Zlatanov <tzz@lifelogs.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:
+
+;; Run this with `GNUTLS_TEST_VERBOSE=1' to get verbose debugging.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl)
+(require 'gnutls)
+(require 'hex-util)
+
+(defvar gnutls-tests-message-prefix "")
+
+(defsubst gnutls-tests-message (format-string &rest args)
+  (when (getenv "GNUTLS_TEST_VERBOSE")
+    (apply #'message (concat "gnutls-tests: " gnutls-tests-message-prefix format-string) args)))
+
+;; Minor convenience to see strings more easily (without binary data).
+(defsubst gnutls-tests-hexstring-equal (a b)
+  (and (stringp a) (stringp b) (string-equal (encode-hex-string a) (encode-hex-string b))))
+
+(defvar gnutls-tests-internal-macs-upcased
+  (mapcar (lambda (sym) (cons sym (intern (upcase (symbol-name sym)))))
+          (secure-hash-algorithms)))
+
+(defvar gnutls-tests-tested-macs
+  (when (gnutls-available-p)
+    (remove-duplicates
+     (append (mapcar 'cdr gnutls-tests-internal-macs-upcased)
+             (mapcar 'car (gnutls-macs))))))
+
+(defvar gnutls-tests-tested-digests
+  (when (gnutls-available-p)
+    (remove-duplicates
+     (append (mapcar 'cdr gnutls-tests-internal-macs-upcased)
+             (mapcar 'car (gnutls-digests))))))
+
+(defvar gnutls-tests-tested-ciphers
+  (when (gnutls-available-p)
+    (remove-duplicates
+    ; these cause FPEs or SEGVs
+     (remove-if (lambda (e) (memq e '(ARCFOUR-128)))
+                (mapcar 'car (gnutls-ciphers))))))
+
+(defvar gnutls-tests-mondo-strings
+  (list
+   ""
+   "some data"
+   "lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data lots and lots of data "
+   "data and more data to go over the block limit!"
+   "data and more data to go over the block limit"
+   (format "some random data %d%d" (random) (random))))
+
+(ert-deftest test-gnutls-000-availability ()
+  "Test the GnuTLS hashes and ciphers availability."
+  (skip-unless (memq 'gnutls3 (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "availability: ")
+  (should (> (length gnutls-tests-internal-macs-upcased) 5))
+  (let ((macs (gnutls-macs))
+        (digests (gnutls-digests))
+        (ciphers (gnutls-ciphers)))
+    (dolist (mac gnutls-tests-tested-macs)
+      (let ((plist (cdr (assq mac macs))))
+        (gnutls-tests-message "MAC %s %S" mac plist)
+        (dolist (prop '(:mac-algorithm-id :mac-algorithm-length :mac-algorithm-keysize :mac-algorithm-noncesize))
+          (should (plist-get plist prop)))
+        (should (eq 'gnutls-mac-algorithm (plist-get plist :type)))))
+    (dolist (digest gnutls-tests-tested-digests)
+      (let ((plist (cdr (assq digest digests))))
+        (gnutls-tests-message "digest %s %S" digest plist)
+        (dolist (prop '(:digest-algorithm-id :digest-algorithm-length))
+          (should (plist-get plist prop)))
+        (should (eq 'gnutls-digest-algorithm (plist-get plist :type)))))
+    (dolist (cipher gnutls-tests-tested-ciphers)
+      (let ((plist (cdr (assq cipher ciphers))))
+        (gnutls-tests-message "cipher %s %S" cipher plist)
+        (dolist (prop '(:cipher-id :cipher-blocksize :cipher-keysize :cipher-ivsize))
+          (should (plist-get plist prop)))
+        (should (eq 'gnutls-symmetric-cipher (plist-get plist :type)))))))
+
+(ert-deftest test-gnutls-000-data-extractions ()
+  "Test the GnuTLS data extractions against the built-in `secure-hash'."
+  (skip-unless (memq 'digests (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "data extraction: ")
+  (dolist (input gnutls-tests-mondo-strings)
+    ;; Test buffer extraction
+    (with-temp-buffer
+      (insert input)
+      (insert "not ASCII: не e английски")
+      (dolist (step '(0 1 2 3 4 5))
+        (let ((spec (list (current-buffer) ; a buffer spec
+                          (point-min)
+                          (max (point-min) (- step (point-max)))))
+              (spec2 (list (buffer-string) ; a string spec
+                           (point-min)
+                           (max (point-min) (- step (point-max))))))
+          (should (gnutls-tests-hexstring-equal
+                   (gnutls-hash-digest 'MD5 spec)
+                   (apply 'secure-hash 'md5 (append spec '(t)))))
+          (should (gnutls-tests-hexstring-equal
+                   (gnutls-hash-digest 'MD5 spec2)
+                   (apply 'secure-hash 'md5 (append spec2 '(t))))))))))
+
+(ert-deftest test-gnutls-001-hashes-internal-digests ()
+  "Test the GnuTLS hash digests against the built-in `secure-hash'."
+  (skip-unless (memq 'digests (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "digest internal verification: ")
+  (let ((macs (gnutls-macs)))
+    (dolist (mcell gnutls-tests-internal-macs-upcased)
+      (let ((plist (cdr (assq (cdr mcell) macs))))
+        (gnutls-tests-message "Checking digest MAC %S %S" mcell plist)
+        (dolist (input gnutls-tests-mondo-strings)
+          ;; Test buffer extraction
+          (with-temp-buffer
+            (insert input)
+            (should (gnutls-tests-hexstring-equal
+                     (gnutls-hash-digest (cdr mcell) (current-buffer))
+                     (secure-hash (car mcell) (current-buffer) nil nil t))))
+          (should (gnutls-tests-hexstring-equal
+                   (gnutls-hash-digest (cdr mcell) input)
+                   (secure-hash (car mcell) input nil nil t))))))))
+
+(ert-deftest test-gnutls-002-hashes-digests ()
+  "Test some GnuTLS hash digests against pre-defined outputs."
+  (skip-unless (memq 'digests (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "digest external verification: ")
+  (let ((macs (gnutls-macs)))
+    (dolist (test '(("57edf4a22be3c955ac49da2e2107b67a" "12345678901234567890123456789012345678901234567890123456789012345678901234567890" MD5)
+                    ("d174ab98d277d9f5a5611c2c9f419d9f" "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" MD5)
+                    ("c3fcd3d76192e4007dfb496cca67e13b" "abcdefghijklmnopqrstuvwxyz" MD5)
+                    ("f96b697d7cb7938d525a2f31aaf161d0" "message digest" MD5)
+                    ("900150983cd24fb0d6963f7d28e17f72" "abc" MD5)
+                    ("0cc175b9c0f1b6a831c399e269772661" "a" MD5)
+                    ("a9993e364706816aba3e25717850c26c9cd0d89d" "abc" SHA1)
+                    ("a9993e364706816aba3e25717850c26c9cd0d89d" "abc" "SHA1"))) ; check string ID for digest
+      (destructuring-bind (hash input mac) test
+        (let ((plist (cdr (assq mac macs)))
+              result resultb)
+        (gnutls-tests-message "%s %S" mac plist)
+        (setq result (encode-hex-string (gnutls-hash-digest mac input)))
+        (gnutls-tests-message "%S => result %S" test result)
+        (should (string-equal result hash))
+        ;; Test buffer extraction
+        (with-temp-buffer
+          (insert input)
+          (setq resultb (encode-hex-string (gnutls-hash-digest mac (current-buffer))))
+          (gnutls-tests-message "%S => result from buffer %S" test resultb)
+          (should (string-equal resultb hash))))))))
+
+(ert-deftest test-gnutls-003-hashes-hmacs ()
+  "Test some predefined GnuTLS HMAC outputs for SHA256."
+  (skip-unless (memq 'macs (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "HMAC verification: ")
+  (let ((macs (gnutls-macs)))
+    (dolist (test '(("f5c5021e60d9686fef3bb0414275fe4163bece61d9a95fec7a273746a437b986" "hello\n" "test" SHA256)
+                    ("46b75292b81002fd873e89c532a1b8545d6efc9822ee938feba6de2723161a67" "more and more data goes into a file to exceed the buffer size" "test" SHA256)
+                    ("81568ba71fa2c5f33cc84bf362466988f98eba3735479100b4e8908acad87ac4" "more and more data goes into a file to exceed the buffer size" "very long key goes here to exceed the key size" SHA256)
+                    ("4bc830005783a73b8112f4bd5f4aa5f92e05b51e9b55c0cd6f9a7bee48371def" "more and more data goes into a file to exceed the buffer size" "" "SHA256") ; check string ID for HMAC
+                    ("4bc830005783a73b8112f4bd5f4aa5f92e05b51e9b55c0cd6f9a7bee48371def" "more and more data goes into a file to exceed the buffer size" "" SHA256)))
+      (destructuring-bind (hash input key mac) test
+        (let ((plist (cdr (assq mac macs)))
+              result)
+          (gnutls-tests-message "%s %S" mac plist)
+          (setq result (encode-hex-string (gnutls-hash-mac mac (copy-sequence key) input)))
+          (gnutls-tests-message "%S => result %S" test result)
+          (should (string-equal result hash)))))))
+
+
+(defun gnutls-tests-pad-or-trim (s exact)
+  "Pad or trim string S to EXACT numeric size."
+  (if (and (consp s) (eq 'iv-auto (nth 0 s)))
+      s
+    (let ((e (number-to-string exact)))
+      (format (concat "%" e "." e "s") s))))
+
+(defun gnutls-tests-pad-to-multiple (s blocksize)
+  "Pad string S to BLOCKSIZE numeric size."
+  (let* ((e (if (string= s "")
+               blocksize
+              (* blocksize (ceiling (length s) blocksize))))
+         (out (concat s (make-string (- e (length s)) ? ))))
+    ;; (gnutls-tests-message "padding %S to length %d for blocksize %d: => %S" s e blocksize out)
+    out))
+
+;; ;;; Testing from the command line:
+;; ;;; echo e36a9d13c15a6df23a59a6337d6132b8f7cd5283cb4784b81141b52343a18e5f5e5ee8f5553c23167409dd222478bc30 | perl -lne 'print pack "H*", $_' | openssl enc -aes-128-ctr -d  -nosalt -K 6d796b657932 -iv 696e697432 | od -x
+(ert-deftest test-gnutls-004-symmetric-ciphers ()
+  "Test the GnuTLS symmetric ciphers"
+  (skip-unless (memq 'ciphers (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "symmetric cipher verification: ")
+  ;; we expect at least 10 ciphers
+  (should (> (length (gnutls-ciphers)) 10))
+  (let ((keys '("mykey" "mykey2"))
+        (inputs gnutls-tests-mondo-strings)
+        (ivs '("" "-abc123-" "init" "ini2"))
+        (ciphers (remove-if
+                  (lambda (c) (plist-get (cdr (assq c (gnutls-ciphers)))
+                                    :cipher-aead-capable))
+                  gnutls-tests-tested-ciphers)))
+
+    (dolist (cipher ciphers)
+      (dolist (iv ivs)
+        (dolist (input inputs)
+          (dolist (key keys)
+            (gnutls-tests-message "%S, starting key %S IV %S input %S" (assq cipher (gnutls-ciphers)) key iv input)
+            (let* ((cplist (cdr (assq cipher (gnutls-ciphers))))
+                   (key (gnutls-tests-pad-or-trim key (plist-get cplist :cipher-keysize)))
+                   (input (gnutls-tests-pad-to-multiple input (plist-get cplist :cipher-blocksize)))
+                   (iv (gnutls-tests-pad-or-trim iv (plist-get cplist :cipher-ivsize)))
+                   (output (gnutls-symmetric-encrypt cplist (copy-sequence key) iv input))
+                   (data (nth 0 output))
+                   (actual-iv (nth 1 output))
+                   (reverse-output (gnutls-symmetric-decrypt cplist (copy-sequence key) actual-iv data))
+                   (reverse (nth 0 reverse-output)))
+              (gnutls-tests-message "%s %S" cipher cplist)
+              (gnutls-tests-message "key %S IV %S input %S => hexdata %S and reverse %S" key iv input (encode-hex-string data) reverse)
+              (should-not (gnutls-tests-hexstring-equal input data))
+              (should-not (gnutls-tests-hexstring-equal data reverse))
+              (should (gnutls-tests-hexstring-equal input reverse)))))))))
+
+(ert-deftest test-gnutls-005-aead-ciphers ()
+  "Test the GnuTLS AEAD ciphers"
+  (skip-unless (memq 'AEAD-ciphers (gnutls-available-p)))
+  (setq gnutls-tests-message-prefix "AEAD verification: ")
+  (let ((keys '("mykey" "mykey2"))
+        (inputs gnutls-tests-mondo-strings)
+        (ivs '("" "-abc123-" "init" "ini2"))
+        (auths '(nil
+                 ""
+                 "auth data"
+                 "auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data auth and auth of data "
+                 "AUTH data and more data to go over the block limit!"
+                 "AUTH data and more data to go over the block limit"))
+        (ciphers (remove-if
+                  (lambda (c) (or (null (plist-get (cdr (assq c (gnutls-ciphers)))
+                                              :cipher-aead-capable))))
+                  gnutls-tests-tested-ciphers))
+        actual-ivlist)
+
+    (dolist (cipher ciphers)
+      (dolist (input inputs)
+        (dolist (auth auths)
+          (dolist (key keys)
+            (let* ((cplist (cdr (assq cipher (gnutls-ciphers))))
+                   (key (gnutls-tests-pad-or-trim key (plist-get cplist :cipher-keysize)))
+                   (input (gnutls-tests-pad-to-multiple input (plist-get cplist :cipher-blocksize)))
+                   (ivsize (plist-get cplist :cipher-ivsize)))
+              (should (>= ivsize 12))   ; as per the RFC
+              (dolist (iv (append ivs (list (list 'iv-auto ivsize))))
+
+                (gnutls-tests-message "%S, starting key %S IV %S input %S auth %S" (assq cipher (gnutls-ciphers)) key iv input auth)
+                (let* ((iv (gnutls-tests-pad-or-trim iv (plist-get cplist :cipher-ivsize)))
+                       (output (gnutls-symmetric-encrypt cplist (copy-sequence key) iv input (copy-sequence auth)))
+                       (data (nth 0 output))
+                       (actual-iv (nth 1 output))
+                       (reverse-output (gnutls-symmetric-decrypt cplist (copy-sequence key) actual-iv data auth))
+                       (reverse (nth 0 reverse-output)))
+                  ;; GNUTLS_RND_NONCE should be good enough to ensure this.
+                  (should-not (member (secure-hash 'sha384 actual-iv 0 ivsize) actual-ivlist))
+                  (cond
+                   ((stringp iv)
+                    (should (equal iv actual-iv)))
+                   ((consp iv)
+                    (push (secure-hash 'sha384 actual-iv 0 ivsize) actual-ivlist)
+                    (gnutls-tests-message "IV list length: %d" (length actual-ivlist))))
+
+                  (gnutls-tests-message "%s %S" cipher cplist)
+                  (gnutls-tests-message "key %S IV %S input %S auth %S => hexdata %S and reverse %S" key iv input auth (encode-hex-string data) reverse)
+                  (should-not (gnutls-tests-hexstring-equal input data))
+                  (should-not (gnutls-tests-hexstring-equal data reverse))
+                  (should (gnutls-tests-hexstring-equal input reverse)))))))))))
+
+(provide 'gnutls-tests)
+;;; gnutls-tests.el ends here
diff --git a/test/lisp/net/network-stream-tests.el b/test/lisp/net/network-stream-tests.el
index e7bb3e8ccf9..9ee3a281c3d 100644
--- a/test/lisp/net/network-stream-tests.el
+++ b/test/lisp/net/network-stream-tests.el
@@ -280,8 +280,11 @@
                       (< (setq times (1+ times)) 10))
             (sit-for 0.1))
           (should proc)
-          (while (eq (process-status proc) 'connect)
-            (sit-for 0.1)))
+          (setq times 0)
+          (while (and (eq (process-status proc) 'connect)
+                      (< (setq times (1+ times)) 10))
+            (sit-for 0.1))
+          (skip-unless (not (eq (process-status proc) 'connect))))
       (if (process-live-p server) (delete-process server)))
     (setq status (gnutls-peer-status proc))
     (should (consp status))
diff --git a/test/lisp/net/tramp-tests.el b/test/lisp/net/tramp-tests.el
index 6c02daa6547..bb1bafa789f 100644
--- a/test/lisp/net/tramp-tests.el
+++ b/test/lisp/net/tramp-tests.el
@@ -86,8 +86,8 @@
       tramp-message-show-message nil
       tramp-persistency-file-name nil)
 
-;; This shall happen on hydra only.
-(when (getenv "NIX_STORE")
+;; This should happen on hydra only.
+(when (getenv "EMACS_HYDRA_CI")
   (add-to-list 'tramp-remote-path 'tramp-own-remote-path))
 
 (defvar tramp--test-expensive-test
@@ -132,12 +132,12 @@ If QUOTED is non-nil, the local part of the file is quoted."
     (make-temp-name "tramp-test")
     (if local temporary-file-directory tramp-test-temporary-file-directory))))
 
-;; Don't print messages in nested `tramp--instrument-test-case' calls.
-(defvar tramp--instrument-test-case-p nil
-  "Whether `tramp--instrument-test-case' run.
+;; Don't print messages in nested `tramp--test-instrument-test-case' calls.
+(defvar tramp--test-instrument-test-case-p nil
+  "Whether `tramp--test-instrument-test-case' run.
 This shall used dynamically bound only.")
 
-(defmacro tramp--instrument-test-case (verbose &rest body)
+(defmacro tramp--test-instrument-test-case (verbose &rest body)
   "Run BODY with `tramp-verbose' equal VERBOSE.
 Print the the content of the Tramp debug buffer, if BODY does not
 eval properly in `should' or `should-not'.  `should-error' is not
@@ -150,9 +150,9 @@ handled properly.  BODY shall not contain a timeout."
           (cons "^make-symbolic-link not supported$" debug-ignored-errors))
          inhibit-message)
      (unwind-protect
-         (let ((tramp--instrument-test-case-p t)) ,@body)
+         (let ((tramp--test-instrument-test-case-p t)) ,@body)
        ;; Unwind forms.
-       (when (and (null tramp--instrument-test-case-p) (> tramp-verbose 3))
+       (when (and (null tramp--test-instrument-test-case-p) (> tramp-verbose 3))
          (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
            (with-current-buffer (tramp-get-connection-buffer v)
              (message "%s" (buffer-string)))
@@ -161,7 +161,7 @@ handled properly.  BODY shall not contain a timeout."
 
 (defsubst tramp--test-message (fmt-string &rest arguments)
   "Emit a message into ERT *Messages*."
-  (tramp--instrument-test-case 0
+  (tramp--test-instrument-test-case 0
     (apply
      'tramp-message
      (tramp-dissect-file-name tramp-test-temporary-file-directory) 0
@@ -169,7 +169,7 @@ handled properly.  BODY shall not contain a timeout."
 
 (defsubst tramp--test-backtrace ()
   "Dump a backtrace into ERT *Messages*."
-  (tramp--instrument-test-case 10
+  (tramp--test-instrument-test-case 10
     (tramp-backtrace
      (tramp-dissect-file-name tramp-test-temporary-file-directory))))
 
@@ -3699,11 +3699,14 @@ process sentinels.  They shall not disturb each other."
            (process-file-side-effects t)
            ;; Suppress nasty messages.
            (inhibit-message t)
+           ;; Do not run delayed timers.
+           (timer-max-repeats 0)
+           ;; Number of asynchronous processes for test.
            (number-proc 10)
            ;; On hydra, timings are bad.
            (timer-repeat
             (cond
-             ((getenv "NIX_STORE") 10)
+             ((getenv "EMACS_HYDRA_CI") 10)
              (t 1)))
            ;; We must distinguish due to performance reasons.
            (timer-operation
@@ -3726,16 +3729,26 @@ process sentinels.  They shall not disturb each other."
               0 timer-repeat
               (lambda ()
                 (when buffers
-                  (let ((default-directory tmp-name)
+                  (let ((time (float-time))
+                        (default-directory tmp-name)
                         (file
                          (buffer-name (nth (random (length buffers)) buffers))))
-                    (funcall timer-operation file))))))
+                    (tramp--test-message
+                     "Start timer %s %s" file (current-time-string))
+                    (funcall timer-operation file)
+                    ;; Adjust timer if it takes too much time.
+                    (when (> (- (float-time) time) timer-repeat)
+                      (setq timer-repeat (* 1.5 timer-repeat))
+                      (setf (timer--repeat-delay timer) timer-repeat)
+                      (tramp--test-message "Increase timer %s" timer-repeat))
+                    (tramp--test-message
+                     "Stop timer %s %s" file (current-time-string)))))))
 
             ;; Create temporary buffers.  The number of buffers
             ;; corresponds to the number of processes; it could be
             ;; increased in order to make pressure on Tramp.
             (dotimes (_i number-proc)
-              (add-to-list 'buffers (generate-new-buffer "foo")))
+              (setq buffers (cons (generate-new-buffer "foo") buffers)))
 
             ;; Open asynchronous processes.  Set process filter and sentinel.
             (dolist (buf buffers)
@@ -3776,17 +3789,30 @@ process sentinels.  They shall not disturb each other."
                        (proc (get-buffer-process buf))
                        (file (process-get proc 'foo))
                        (count (process-get proc 'bar)))
+                  (tramp--test-message
+                   "Start action %d %s %s" count buf (current-time-string))
                   ;; Regular operation.
                   (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))
                   (if (= count 2)
-                      (should-not (file-attributes file))
+                      (if (= (length buffers) 1)
+                          (tramp--test-instrument-test-case 10
+                            (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))
                   (process-put proc 'bar (1+ count))
                   (unless (process-live-p proc)
                     (setq buffers (delq buf buffers))))))
@@ -3794,6 +3820,8 @@ 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))
             (dolist (buf buffers)
               (with-current-buffer buf
                 (should (string-equal (format "%s\n" buf) (buffer-string)))))
@@ -3857,8 +3885,6 @@ process sentinels.  They shall not disturb each other."
 (ert-deftest tramp-test39-unload ()
   "Check that Tramp and its subpackages unload completely.
 Since it unloads Tramp, it shall be the last test to run."
-  ;; Mark as failed until all symbols are unbound.
-  :expected-result (if (featurep 'tramp) :failed :passed)
   :tags '(:expensive-test)
   (skip-unless noninteractive)
 
@@ -3869,21 +3895,31 @@ Since it unloads Tramp, it shall be the last test to run."
     (should-not (all-completions "tramp" (delq 'tramp-tests features)))
     ;; `file-name-handler-alist' must be clean.
     (should-not (all-completions "tramp" (mapcar 'cdr file-name-handler-alist)))
-    ;; There shouldn't be left a bound symbol.  We do not regard our
-    ;; test symbols, and the Tramp unload hooks.
+    ;; There shouldn't be left a bound symbol, except buffer-local
+    ;; variables, and autoload functions.  We do not regard our test
+    ;; symbols, and the Tramp unload hooks.
     (mapatoms
      (lambda (x)
-       (and (or (boundp x) (functionp x))
+       (and (or (and (boundp x) (null (local-variable-if-set-p x)))
+                (and (functionp x) (null (autoloadp (symbol-function x)))))
             (string-match "^tramp" (symbol-name x))
             (not (string-match "^tramp--?test" (symbol-name x)))
             (not (string-match "unload-hook$" (symbol-name x)))
             (ert-fail (format "`%s' still bound" x)))))
+    ;; The defstruct `tramp-file-name' and all its internal functions
+    ;; shall be purged.
+    (should-not (cl--find-class 'tramp-file-name))
+    (mapatoms
+     (lambda (x)
+       (and (string-match "tramp-file-name" (symbol-name x))
+            (functionp 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.
     (mapatoms
      (lambda (x)
        (and (boundp x)
-            (string-match "-hooks?$" (symbol-name x))
+            (string-match "-\\(hook\\|function\\)s?$" (symbol-name x))
             (not (string-match "unload-hook$" (symbol-name x)))
             (consp (symbol-value x))
             (ignore-errors (all-completions "tramp" (symbol-value x)))
@@ -3904,11 +3940,7 @@ Since it unloads Tramp, it shall be the last test to run."
 ;; * Fix `tramp-test05-expand-file-name-relative' in `expand-file-name'.
 ;; * Fix `tramp-test06-directory-file-name' for `ftp'.
 ;; * Fix `tramp-test27-start-file-process' on MS Windows (`process-send-eof'?).
-;; * Fix Bug#27009.  Set expected error of
-;;   `tramp-test29-environment-variables-and-port-numbers'.
 ;; * Fix Bug#16928 in `tramp-test36-asynchronous-requests'.
-;; * Fix `tramp-test39-unload' (Not all symbols are unbound).  Set
-;;   expected error.
 
 (defun tramp-test-all (&optional interactive)
   "Run all tests for \\[tramp]."
diff --git a/test/lisp/ses-tests.el b/test/lisp/ses-tests.el
new file mode 100644
index 00000000000..8fff6f73520
--- /dev/null
+++ b/test/lisp/ses-tests.el
@@ -0,0 +1,175 @@
+;;; ses-tests.el --- Tests for ses.el              -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015-2017 Free Software Foundation, Inc.
+
+;; Author: Vincent Belaïche <vincentb1@users.sourceforge.net>
+
+;; 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/>.
+
+;;; Code:
+
+(require 'ert)
+(require 'ses)
+
+
+;; PLAIN FORMULA TESTS
+;; ======================================================================
+
+(ert-deftest ses-tests-lowlevel-plain-formula ()
+  "Check that setting A1 to 1 and A2 to (1+ A1), makes A2 value
+equal to 2. This is done with low level functions calls, not like
+interactively."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'ses-cell-set-formula c)
+        (apply 'ses-calculate-cell (list (car c) (cadr c) nil)))
+      (should (eq A2 2)))))
+
+(ert-deftest ses-tests-plain-formula ()
+  "Check that setting A1 to 1 and A2 to (1+ A1), makes A2 value
+equal to 2. This is done  using interactive calls."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook)
+      (should (eq A2 2)))))
+
+;; PLAIN CELL RENAMING TESTS
+;; ======================================================================
+
+(ert-deftest ses-tests-lowlevel-renamed-cell ()
+  "Check that renaming A1 to `foo' and setting `foo' to 1 and A2 to (1+ foo), makes A2 value equal to 2.
+This is done using low level functions, `ses-rename-cell' is not
+called but instead we use text replacement in the buffer
+previously passed in text mode."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'ses-cell-set-formula c)
+        (apply 'ses-calculate-cell (list (car c) (cadr c) nil)))
+      (ses-write-cells)
+      (text-mode)
+      (goto-char (point-min))
+      (while (re-search-forward "\\<A1\\>" nil t)
+        (replace-match "foo" t t))
+      (ses-mode)
+      (should-not  (local-variable-p 'A1))
+      (should (eq foo 1))
+      (should (equal (ses-cell-formula 1 0) '(ses-safe-formula (1+ foo))))
+      (should (eq A2 2)))))
+
+(ert-deftest ses-tests-renamed-cell ()
+  "Check that renaming A1 to `foo' and setting `foo' to 1 and A2
+to (1+ foo), makes A2 value equal to 2."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (ses-rename-cell 'foo (ses-get-cell 0 0))
+      (dolist (c '((0 0 1) (1 0 (1+ foo))))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook)
+      (should-not  (local-variable-p 'A1))
+      (should (eq foo 1))
+      (should (equal (ses-cell-formula 1 0) '(1+ foo)))
+      (should (eq A2 2)))))
+
+(ert-deftest ses-tests-renamed-cell-after-setting ()
+  "Check that setting A1 to 1 and A2 to (1+ A1), and then
+renaming A1 to `foo' makes `foo' value equal to 2."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook); deferred recalc
+      (ses-rename-cell 'foo (ses-get-cell 0 0))
+      (should-not  (local-variable-p 'A1))
+      (should (eq foo 1))
+      (should (equal (ses-cell-formula 1 0) '(1+ foo)))
+      (should (eq A2 2)))))
+
+(ert-deftest ses-tests-renaming-cell-with-one-symbol-formula ()
+  "Check that setting A1 to 1 and A2 to A1, and then renaming A1
+to `foo' makes `foo' value equal to 1. Then set A1 to 2 and check
+that `foo' becomes 2."
+  (let ((ses-initial-size '(3 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 A1)))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook); deferred recalc
+      (ses-rename-cell 'foo (ses-get-cell 0 0))
+      (ses-command-hook); deferred recalc
+      (should-not  (local-variable-p 'A1))
+      (should (eq foo 1))
+      (should (equal (ses-cell-formula 1 0) 'foo))
+      (should (eq A2 1))
+      (funcall-interactively 'ses-edit-cell 0 0 2)
+      (ses-command-hook); deferred recalc
+      (should (eq A2 2))
+      (should (eq foo 2)))))
+
+
+;; ROW INSERTION TESTS
+;; ======================================================================
+
+(ert-deftest ses-tests-plain-row-insertion ()
+  "Check that setting A1 to 1 and A2 to (1+ A1), and then jumping
+to A2 and inserting a row, makes A2 value empty, and A3 equal to
+2."
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook)
+      (ses-jump 'A2)
+      (ses-insert-row 1)
+      (ses-command-hook)
+      (should-not A2)
+      (should (eq A3 2)))))
+
+; (defvar ses-tests-trigger nil)
+
+(ert-deftest ses-tests-renamed-cells-row-insertion ()
+  "Check that setting A1 to 1 and A2 to (1+ A1), and then renaming A1 to `foo' and A2 to `bar' jumping
+to `bar' and inserting a row, makes A2 value empty, and `bar' equal to
+2."
+  (setq ses-tests-trigger nil)
+  (let ((ses-initial-size '(2 . 1)))
+    (with-temp-buffer
+      (ses-mode)
+      (dolist (c '((0 0 1) (1 0 (1+ A1))))
+        (apply 'funcall-interactively 'ses-edit-cell c))
+      (ses-command-hook)
+      (ses-rename-cell 'foo (ses-get-cell 0 0))
+      (ses-command-hook)
+      (ses-rename-cell 'bar (ses-get-cell 1 0))
+      (ses-command-hook)
+      (should (eq bar 2))
+      (ses-jump 'bar)
+      (ses-insert-row 1)
+      (ses-command-hook)
+      (should-not A2)
+      (should (eq bar 2)))))
+
+
+(provide 'ses-tests)
diff --git a/test/lisp/subr-tests.el b/test/lisp/subr-tests.el
index 54f4ab5d1b2..7e50429a5bf 100644
--- a/test/lisp/subr-tests.el
+++ b/test/lisp/subr-tests.el
@@ -258,9 +258,9 @@ This exercises `backtrace-frame', and indirectly `mapbacktrace'."
     (should (equal (mapbacktrace #'error unbound) nil)))
   ;; First frame is backtrace-related function
   (should (equal (backtrace-frame 0) '(t backtrace-frame 0)))
-  (should (equal (catch 'ret
-                   (mapbacktrace (lambda (&rest args) (throw 'ret args))))
-                 '(t mapbacktrace ((lambda (&rest args) (throw 'ret args))) nil)))
+  (let ((throw-args (lambda (&rest args) (throw 'ret args))))
+    (should (equal (catch 'ret (mapbacktrace throw-args))
+                   `(t mapbacktrace (,throw-args) nil))))
   ;; Past-end NFRAMES is silently ignored
   (should (equal (backtrace-frame most-positive-fixnum) nil)))
 
diff --git a/test/manual/BidiCharacterTest.txt b/test/manual/BidiCharacterTest.txt
index 7e04d6cb3c0..a3d2b46cc40 100644
--- a/test/manual/BidiCharacterTest.txt
+++ b/test/manual/BidiCharacterTest.txt
@@ -1,6 +1,6 @@
-# BidiCharacterTest-9.0.0.txt
-# Date: 2016-01-15, 22:30:00 GMT [LI]
-# © 2016 Unicode®, Inc.
+# BidiCharacterTest-10.0.0.txt
+# Date: 2017-03-09, 00:30:00 GMT [LI]
+# © 2017 Unicode®, Inc.
 # For terms of use, see http://www.unicode.org/terms_of_use.html
 #
 # Unicode Character Database
diff --git a/test/manual/etags/CTAGS.good b/test/manual/etags/CTAGS.good
index 13bb37c2e6a..519315c6fdd 100644
--- a/test/manual/etags/CTAGS.good
+++ b/test/manual/etags/CTAGS.good
@@ -202,6 +202,7 @@ ${CHECKOBJS}	make-src/Makefile	/^${CHECKOBJS}: CFLAGS=-g3 -DNULLFREECHECK=0$/
 =\relax tex-src/texinfo.tex     /^\\let\\subsubsection=\\relax$/
 =\relax tex-src/texinfo.tex     /^\\let\\appendix=\\relax$/
 =\smartitalic   tex-src/texinfo.tex     /^\\let\\cite=\\smartitalic$/
+=starts-with-equals!    scm-src/test.scm        /^(define =starts-with-equals! #t)$/
 >       tex-src/texinfo.tex     /^\\def>{{\\tt \\gtr}}$/
 >field1 forth-src/test-forth.fth        /^   9   field   >field1$/
 >field2 forth-src/test-forth.fth        /^   5   field   >field2$/
@@ -2750,6 +2751,7 @@ current-idle-time	c-src/emacs/src/keyboard.c	/^DEFUN ("current-idle-time", Fcurr
 current-input-mode      c-src/emacs/src/keyboard.c      /^DEFUN ("current-input-mode", Fcurrent_input_mode, /
 current_kboard  c-src/emacs/src/keyboard.c      85
 current_lb_is_new       c-src/etags.c   2926
+curry-test      scm-src/test.scm        /^(define (((((curry-test a) b) c) d) e)$/
 cursor_position cp-src/screen.cpp       /^void cursor_position(void)$/
 cursor_x        cp-src/screen.cpp       15
 cursor_y        cp-src/screen.cpp       15
@@ -3037,6 +3039,7 @@ foo	ruby-src/test1.ru	/^    attr_reader :foo$/
 foo!    ruby-src/test1.ru       /^    def foo!$/
 foo1    ruby-src/test1.ru       /^    attr_reader(:foo1, :bar1, # comment$/
 foo2    ruby-src/test1.ru       /^    alias_method ( :foo2, #cmmt$/
+foo==bar        el-src/TAGTEST.EL       /^(defun foo==bar () (message "hi"))  ; Bug#5624$/
 foobar  c-src/c.c       /^int foobar() {;}$/
 foobar  c.c     /^extern void foobar (void) __attribute__ ((section /
 foobar2 c-src/h.h       20
@@ -3161,6 +3164,9 @@ header	c-src/emacs/src/lisp.h	1672
 header  c-src/emacs/src/lisp.h  1826
 header_size     c-src/emacs/src/lisp.h  1471
 heapsize        c-src/emacs/src/gmalloc.c       361
+hello   scm-src/test.scm        /^(define hello "Hello, Emacs!")$/
+hello   scm-src/test.scm        /^(set! hello "Hello, world!")$/
+hello-world     scm-src/test.scm        /^(define (hello-world)$/
 help    c-src/etags.c   193
 helpPanel       objcpp-src/SimpleCalc.M /^- helpPanel:sender$/
 help_char_p     c-src/emacs/src/keyboard.c      /^help_char_p (Lisp_Object c)$/
@@ -4317,10 +4323,12 @@ test	erl-src/gs_dialog.erl	/^test() ->$/
 test    go-src/test1.go /^func test(p plus) {$/
 test    make-src/Makefile       /^test:$/
 test    php-src/ptest.php       /^test $/
+test-begin      scm-src/test.scm        /^(define-syntax test-begin$/
 test.me22b      lua-src/test.lua        /^   local function test.me22b (one)$/
 test.me_22a     lua-src/test.lua        /^   function test.me_22a(one, two)$/
 test_undefined  c-src/emacs/src/keyboard.c      /^test_undefined (Lisp_Object binding)$/
 texttreelist    prol-src/natded.prolog  /^texttreelist([]).$/
+there-is-a-=-in-the-middle!     scm-src/test.scm        /^(define (there-is-a-=-in-the-middle!) #t)$/
 this    c-src/a/b/b.c   1
 this-command-keys       c-src/emacs/src/keyboard.c      /^DEFUN ("this-command-keys", Fthis_command_keys, St/
 this-command-keys-vector        c-src/emacs/src/keyboard.c      /^DEFUN ("this-command-keys-vector", Fthis_command_k/
diff --git a/test/manual/etags/ETAGS.good_1 b/test/manual/etags/ETAGS.good_1
index 6c4a02ae1c1..cd9cd4a8450 100644
--- a/test/manual/etags/ETAGS.good_1
+++ b/test/manual/etags/ETAGS.good_1
@@ -2143,10 +2143,11 @@ main(37,571
         class D 41,622
                 D(43,659
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5069
 (defvar tags-file-name 34,1034
@@ -3135,6 +3136,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -3145,11 +3155,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/ETAGS.good_2 b/test/manual/etags/ETAGS.good_2
index fa784d2e7b5..54fd00e95da 100644
--- a/test/manual/etags/ETAGS.good_2
+++ b/test/manual/etags/ETAGS.good_2
@@ -2712,10 +2712,11 @@ main(37,571
         class D 41,622
                 D(43,659
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5188
 (defvar tags-file-name 34,1034
@@ -3708,6 +3709,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -3718,11 +3728,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/ETAGS.good_3 b/test/manual/etags/ETAGS.good_3
index 547dee2d43c..508427c501c 100644
--- a/test/manual/etags/ETAGS.good_3
+++ b/test/manual/etags/ETAGS.good_3
@@ -2520,10 +2520,11 @@ main(37,571
                 D(43,659
                 int x;44,694
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5069
 (defvar tags-file-name 34,1034
@@ -3542,6 +3543,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -3552,11 +3562,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/ETAGS.good_4 b/test/manual/etags/ETAGS.good_4
index 2c50ec1a742..460e31b5d96 100644
--- a/test/manual/etags/ETAGS.good_4
+++ b/test/manual/etags/ETAGS.good_4
@@ -2307,10 +2307,11 @@ main(37,571
         class D 41,622
                 D(43,659
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5069
 (defvar tags-file-name 34,1034
@@ -3299,6 +3300,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -3309,11 +3319,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/ETAGS.good_5 b/test/manual/etags/ETAGS.good_5
index 2b431034f44..b7a31602f51 100644
--- a/test/manual/etags/ETAGS.good_5
+++ b/test/manual/etags/ETAGS.good_5
@@ -3253,10 +3253,11 @@ main(37,571
                 D(43,659
                 int x;44,694
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5188
 (defvar tags-file-name 34,1034
@@ -4279,6 +4280,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -4289,11 +4299,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/ETAGS.good_6 b/test/manual/etags/ETAGS.good_6
index 2cb0d05e72a..a75fd806968 100644
--- a/test/manual/etags/ETAGS.good_6
+++ b/test/manual/etags/ETAGS.good_6
@@ -3253,10 +3253,11 @@ main(37,571
                 D(D::D
43,659
                 int x;D::x
44,694
 
-el-src/TAGTEST.EL,148
+el-src/TAGTEST.EL,179
 (foo::defmumble bletch 1,0
-(defalias 'pending-delete-mode pending-delete-mode
5,102
-(defalias (quote explicitly-quoted-pending-delete-mode)8,175
+(defun foo==bar foo==bar
2,33
+(defalias 'pending-delete-mode pending-delete-mode
6,149
+(defalias (quote explicitly-quoted-pending-delete-mode)9,222
 
 el-src/emacs/lisp/progmodes/etags.el,5188
 (defvar tags-file-name 34,1034
@@ -4279,6 +4280,15 @@ module A9,57
     alias_method ( :foo2,foo2
37,586
 A::Constant Constant
42,655
 
+scm-src/test.scm,260
+(define hello 1,0
+(set! hello 3,32
+(define (hello-world)5,62
+(define (there-is-a-=-in-the-middle!)there-is-a-=-in-the-middle!
10,128
+(define =starts-with-equals! =starts-with-equals!
12,171
+(define (((((curry-test 14,205
+(define-syntax test-begin17,265
+
 tex-src/testenv.tex,52
 \newcommand{\nm}\nm
4,77
 \section{blah}blah
8,139
@@ -4289,11 +4299,11 @@ tex-src/gzip.texi,303
 @node Overview,83,2705
 @node Sample,166,7272
 @node Invoking gzip,Invoking gzip
210,8828
-@node Advanced usage,Advanced usage
357,13495
-@node Environment,420,15207
-@node Tapes,437,15768
-@node Problems,460,16767
-@node Concept Index,Concept Index
473,17287
+@node Advanced usage,Advanced usage
357,13496
+@node Environment,420,15208
+@node Tapes,437,15769
+@node Problems,460,16768
+@node Concept Index,Concept Index
473,17288
 
 tex-src/texinfo.tex,30627
 \def\texinfoversion{\texinfoversion
26,1032
diff --git a/test/manual/etags/Makefile b/test/manual/etags/Makefile
index 07ad0f46416..c1df703905e 100644
--- a/test/manual/etags/Makefile
+++ b/test/manual/etags/Makefile
@@ -25,12 +25,13 @@ PSSRC=$(addprefix ./ps-src/,rfc1245.ps)
 PROLSRC=$(addprefix ./prol-src/,ordsets.prolog natded.prolog)
 PYTSRC=$(addprefix ./pyt-src/,server.py)
 RBSRC=$(addprefix ./ruby-src/,test.rb test1.ru)
+SCMSRC=$(addprefix ./scm-src/,test.scm)
 TEXSRC=$(addprefix ./tex-src/,testenv.tex gzip.texi texinfo.tex nonewline.tex)
 YSRC=$(addprefix ./y-src/,parse.y parse.c atest.y cccp.c cccp.y)
 SRCS=${ADASRC} ${ASRC} ${CSRC} ${CPSRC} ${ELSRC} ${ERLSRC} ${FSRC}\
      ${FORTHSRC} ${GOSRC} ${HTMLSRC} ${JAVASRC} ${LUASRC} ${MAKESRC}\
      ${OBJCSRC} ${OBJCPPSRC} ${PASSRC} ${PHPSRC} ${PERLSRC} ${PSSRC}\
-     ${PROLSRC} ${PYTSRC} ${RBSRC} ${TEXSRC} ${YSRC}
+     ${PROLSRC} ${PYTSRC} ${RBSRC} ${SCMSRC} ${TEXSRC} ${YSRC}
 NONSRCS=./f-src/entry.strange ./erl-src/lists.erl ./cp-src/clheir.hpp.gz
 
 ETAGS_PROG=../../../lib-src/etags
diff --git a/test/manual/etags/el-src/TAGTEST.EL b/test/manual/etags/el-src/TAGTEST.EL
index acf0baf82f0..89a67913771 100644
--- a/test/manual/etags/el-src/TAGTEST.EL
+++ b/test/manual/etags/el-src/TAGTEST.EL
@@ -1,4 +1,5 @@
 (foo::defmumble bletch beuarghh)
+(defun foo==bar () (message "hi"))  ; Bug#5624
 ;;; Ctags test file for lisp mode.
 
 ;; from emacs/lisp/delsel.el:76:
diff --git a/test/manual/etags/scm-src/test.scm b/test/manual/etags/scm-src/test.scm
new file mode 100644
index 00000000000..e3921e718fc
--- /dev/null
+++ b/test/manual/etags/scm-src/test.scm
@@ -0,0 +1,20 @@
+(define hello "Hello, Emacs!")
+
+(set! hello "Hello, world!")
+
+(define (hello-world)
+  (display hello)
+  (newline))
+
+;; Bug 5624
+(define (there-is-a-=-in-the-middle!) #t)
+
+(define =starts-with-equals! #t)
+
+(define (((((curry-test a) b) c) d) e)
+  (list a b c d e))
+
+(define-syntax test-begin
+  (syntax-rules ()
+    ((test-begin exp ...)
+     ((lambda () exp ...)))))
diff --git a/test/manual/image-size-tests.el b/test/manual/image-size-tests.el
index 577c7658791..ad43426dd20 100644
--- a/test/manual/image-size-tests.el
+++ b/test/manual/image-size-tests.el
@@ -25,8 +25,8 @@
 (defmacro im-should (image width height &rest props)
   `(let ((im (im-image ,image ,@props)))
      (unless (im-compare im ,width ,height)
-       (error "%s didn't succeed; size is %s"
-              ',props (image-size im t)))))
+       (error "%s %s didn't succeed; size is %s"
+              ',image ',props (image-size im t)))))
 
 (defun im-image (type &rest props)
   (let ((image-scaling-factor 1))
@@ -67,6 +67,9 @@
   ;; Both max-width/height.
   (im-should :w 100 50 :max-width 100 :max-height 75)
   (im-should :w 50 25 :max-width 100 :max-height 25)
+  ;; :width and :max-height (max-height wins).
+  (im-should :w 400 200 :width 400 :max-height 200)
+  (im-should :w 400 200 :width 500 :max-height 200)
 
   ;; Test the image that's taller than it is wide.
   (im-should :h 100 200)
@@ -87,6 +90,9 @@
   ;; Both max-width/height.
   (im-should :h 50 100 :max-width 75 :max-height 100)
   (im-should :h 25 50 :max-width 25 :max-height 100)
+  ;; :height and :max-width (max-width wins).
+  (im-should :h 200 400 :height 400 :max-width 200)
+  (im-should :h 200 400 :height 500 :max-width 200)
   )
 
 ;;; image-size-tests.el ends here
diff --git a/test/manual/indent/perl.perl b/test/manual/indent/perl.perl
index f86a09b2733..06f32e7f090 100755
--- a/test/manual/indent/perl.perl
+++ b/test/manual/indent/perl.perl
@@ -53,6 +53,14 @@ EOF1
 bar
 EOF2
 
+print <<~"EOF1" . <<\EOF2 . s/he"llo/th'ere/;
+foo
+EOF2
+   bar
+   EOF1
+bar
+EOF2
+
 print $'; # This should not start a string!
 
 print "hello" for /./;
diff --git a/test/src/emacs-module-tests.el b/test/src/emacs-module-tests.el
index a4994b6223b..2aa85f0b247 100644
--- a/test/src/emacs-module-tests.el
+++ b/test/src/emacs-module-tests.el
@@ -182,37 +182,66 @@ changes."
   (should (equal (help-function-arglist #'mod-test-sum)
                  '(arg1 arg2))))
 
-(ert-deftest module--test-assertions ()
-  "Check that -module-assertions work."
+(defmacro module--with-temp-directory (name &rest body)
+  "Bind NAME to the name of a temporary directory and evaluate BODY.
+NAME must be a symbol.  Delete the temporary directory after BODY
+exits normally or non-locally.  NAME will be bound to the
+directory name (not the directory file name) of the temporary
+directory."
+  (declare (indent 1))
+  (cl-check-type name symbol)
+  `(let ((,name (file-name-as-directory
+                 (make-temp-file "emacs-module-test" :directory))))
+     (unwind-protect
+         (progn ,@body)
+       (delete-directory ,name :recursive))))
+
+(defmacro module--test-assertion (pattern &rest body)
+  "Test that PATTERN matches the assertion triggered by BODY.
+Run Emacs as a subprocess, load the test module `mod-test-file',
+and evaluate BODY.  Verify that Emacs aborts and prints a module
+assertion message that matches PATTERN.  PATTERN is evaluated and
+must evaluate to a regular expression string."
+  (declare (indent 1))
+  ;; To contain any core dumps.
+  `(module--with-temp-directory tempdir
+     (with-temp-buffer
+       (let* ((default-directory tempdir)
+              (status (call-process mod-test-emacs nil t nil
+                                    "-batch" "-Q" "-module-assertions" "-eval"
+                                    ,(prin1-to-string
+                                      `(progn
+                                         (require 'mod-test ,mod-test-file)
+                                         ,@body)))))
+         (should (stringp status))
+         ;; eg "Aborted" or "Abort trap: 6"
+         (should (string-prefix-p "Abort" status))
+         (search-backward "Emacs module assertion: ")
+         (goto-char (match-end 0))
+         (should (string-match-p ,pattern
+                                 (buffer-substring-no-properties
+                                  (point) (point-max))))))))
+
+(ert-deftest module--test-assertions--load-non-live-object ()
+  "Check that -module-assertions verify that non-live objects
+aren’t accessed."
   (skip-unless (file-executable-p mod-test-emacs))
   ;; This doesn’t yet cause undefined behavior.
   (should (eq (mod-test-invalid-store) 123))
-  ;; To contain any core dumps.
-  (let ((tempdir (make-temp-file "emacs-module-test" t)))
-    (unwind-protect
-        (with-temp-buffer
-          (should (string-match-p
-                   "Abort" ; eg "Aborted" or "Abort trap: 6"
-                   (let ((default-directory tempdir))
-                     (call-process mod-test-emacs nil t nil
-                                   "-batch" "-Q" "-module-assertions" "-eval"
-                                   (prin1-to-string
-                                    `(progn
-                                       (require 'mod-test ,mod-test-file)
-                                       ;; Storing and reloading a local
-                                       ;; value causes undefined behavior,
-                                       ;; which should be detected by the
-                                       ;; module assertions.
-                                       (mod-test-invalid-store)
-                                       (mod-test-invalid-load)))))))
-          (search-backward "Emacs module assertion:")
-          (should (string-match-p (rx bos "Emacs module assertion: "
-                                      "Emacs value not found in "
-                                      (+ digit) " values of "
-                                      (+ digit) " environments" eos)
-                                  (buffer-substring-no-properties
-                                   (line-beginning-position)
-                                   (line-end-position)))))
-      (delete-directory tempdir t))))
+  (module--test-assertion (rx "Emacs value not found in "
+                              (+ digit) " values of "
+                              (+ digit) " environments\n")
+    ;; Storing and reloading a local value causes undefined behavior,
+    ;; which should be detected by the module assertions.
+    (mod-test-invalid-store)
+    (mod-test-invalid-load)))
+
+(ert-deftest module--test-assertions--call-emacs-from-gc ()
+  "Check that -module-assertions prevents calling Emacs functions
+during garbage collection."
+  (skip-unless (file-executable-p mod-test-emacs))
+  (module--test-assertion
+      (rx "Module function called during garbage collection\n")
+    (mod-test-invalid-finalizer)))
 
 ;;; emacs-module-tests.el ends here
diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el
index 2e463455f0c..e294859226c 100644
--- a/test/src/fns-tests.el
+++ b/test/src/fns-tests.el
@@ -373,6 +373,12 @@
     (should-error (assoc 3 d1) :type 'wrong-type-argument)
     (should-error (assoc 3 d2) :type 'wrong-type-argument)))
 
+(ert-deftest test-assoc-testfn ()
+  (let ((alist '(("a" . 1) ("b" . 2))))
+    (should-not (assoc "a" alist #'ignore))
+    (should (eq (assoc "b" alist #'string-equal) (cadr alist)))
+    (should-not (assoc "b" alist #'eq))))
+
 (ert-deftest test-cycle-rassq ()
   (let ((c1 (cyc1 '(0 . 1)))
         (c2 (cyc2 '(0 . 1) '(0 . 2)))
diff --git a/test/src/lread-tests.el b/test/src/lread-tests.el
index 98cbb6a301d..dd5a2003b41 100644
--- a/test/src/lread-tests.el
+++ b/test/src/lread-tests.el
@@ -142,6 +142,23 @@ literals (Bug#20852)."
                            "unescaped character literals "
                            "`?\"', `?(', `?)', `?;', `?[', `?]' detected!")))))
 
+(ert-deftest lread-tests--funny-quote-symbols ()
+  "Check that 'smart quotes' or similar trigger errors in symbol names."
+  (dolist (quote-char
+           '(#x2018 ;; LEFT SINGLE QUOTATION MARK
+             #x2019 ;; RIGHT SINGLE QUOTATION MARK
+             #x201B ;; SINGLE HIGH-REVERSED-9 QUOTATION MARK
+             #x201C ;; LEFT DOUBLE QUOTATION MARK
+             #x201D ;; RIGHT DOUBLE QUOTATION MARK
+             #x201F ;; DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+             #x301E ;; DOUBLE PRIME QUOTATION MARK
+             #xFF02 ;; FULLWIDTH QUOTATION MARK
+             #xFF07 ;; FULLWIDTH APOSTROPHE
+             ))
+    (let ((str (format "%cfoo" quote-char)))
+     (should-error (read str) :type 'invalid-read-syntax)
+     (should (eq (read (concat "\\" str)) (intern str))))))
+
 (ert-deftest lread-test-bug26837 ()
   "Test for http://debbugs.gnu.org/26837 ."
   (let ((load-path (cons
@@ -164,4 +181,10 @@ literals (Bug#20852)."
                    (concat (format-message "Loading `%s': " file-name)
                            "old-style backquotes detected!")))))
 
+(ert-deftest lread-lread--substitute-object-in-subtree ()
+  (let ((x (cons 0 1)))
+    (setcar x x)
+    (lread--substitute-object-in-subtree x 1 t)
+    (should (eq x (cdr x)))))
+
 ;;; lread-tests.el ends here