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

10 files changed, 531 insertions, 98 deletions

diff --git a/test/src/alloc-tests.el b/test/src/alloc-tests.el
index af4ad6c6355..1cf1fc3be5c 100644
--- a/test/src/alloc-tests.el
+++ b/test/src/alloc-tests.el
@@ -31,3 +31,23 @@
 
 (ert-deftest finalizer-object-type ()
   (should (equal (type-of (make-finalizer nil)) 'finalizer)))
+
+(ert-deftest record-1 ()
+  (let ((x (record 'foo 1 2 3)))
+    (should (recordp x))
+    (should (eq (type-of x) 'foo))
+    (should (eq (aref x 0) 'foo))
+    (should (eql (aref x 3) 3))
+    (should (eql (length x) 4))))
+
+(ert-deftest record-2 ()
+  (let ((x (make-record 'bar 1 0)))
+    (should (eql (length x) 2))
+    (should (eql (aref x 1) 0))))
+
+(ert-deftest record-3 ()
+  (let* ((x (record 'foo 1 2 3))
+         (y (copy-sequence x)))
+    (should-not (eq x y))
+    (dotimes (i 4)
+      (should (eql (aref x i) (aref y i))))))
diff --git a/test/src/casefiddle-tests.el b/test/src/casefiddle-tests.el
index 152d85de006..234d233c71a 100644
--- a/test/src/casefiddle-tests.el
+++ b/test/src/casefiddle-tests.el
@@ -24,36 +24,40 @@
 
 (ert-deftest casefiddle-tests-char-properties ()
   "Sanity check of character Unicode properties."
-  (should-not
-   (let (errors)
-     ;;            character  uppercase  lowercase  titlecase
-     (dolist (test '((?A nil ?a nil)
-                     (?a ?A nil ?A)
-                     (?Ł nil ?ł nil)
-                     (?ł ?Ł nil ?Ł)
-
-                     (?DŽ nil ?dž ?Dž)
-                     (?Dž ?DŽ ?dž ?Dž)
-                     (?dž ?DŽ nil ?Dž)
-
-                     (?Σ nil ?σ nil)
-                     (?σ ?Σ nil ?Σ)
-                     (?ς ?Σ nil ?Σ)
-
-                     (?ⅷ ?Ⅷ nil ?Ⅷ)
-                     (?Ⅷ nil ?ⅷ nil)))
-       (let ((ch (car test))
-             (expected (cdr test))
-             (props '(uppercase lowercase titlecase)))
-         (while props
-           (let ((got (get-char-code-property ch (car props))))
-             (unless (equal (car expected) got)
-               (push (format "\n%c %s; expected: %s but got: %s"
-                             ch (car props) (car expected) got)
-                     errors)))
-           (setq props (cdr props) expected (cdr expected)))))
-     (when errors
-       (mapconcat (lambda (line) line) (nreverse errors) "")))))
+  (let ((props '(uppercase lowercase titlecase
+                 special-uppercase special-lowercase special-titlecase))
+        (tests '((?A nil ?a  nil  nil  nil  nil)
+                 (?a ?A  nil ?A   nil  nil  nil)
+                 (?Ł nil ?ł  nil  nil  nil  nil)
+                 (?ł ?Ł  nil ?Ł   nil  nil  nil)
+
+                 (?DŽ nil ?dž  ?Dž   nil  nil  nil)
+                 (?Dž ?DŽ  ?dž  ?Dž   nil  nil  nil)
+                 (?dž ?DŽ  nil ?Dž   nil  nil  nil)
+
+                 (?Σ nil ?σ  nil  nil  nil  nil)
+                 (?σ ?Σ  nil ?Σ   nil  nil  nil)
+                 (?ς ?Σ  nil ?Σ   nil  nil  nil)
+
+                 (?ⅷ ?Ⅷ  nil ?Ⅷ   nil  nil  nil)
+                 (?Ⅷ nil ?ⅷ  nil  nil  nil  nil)
+
+                 (?fi nil nil nil  "FI" nil "Fi")
+                 (?ß nil nil nil  "SS" nil "Ss")
+                 (?İ nil ?i  nil  nil "i\u0307" nil)))
+        errors)
+    (dolist (test tests)
+      (let ((ch (car test))
+            (expected (cdr test)))
+        (dolist (prop props)
+          (let ((got (get-char-code-property ch prop)))
+            (unless (equal (car expected) got)
+              (push (format "\n%c %s; expected: %s but got: %s"
+                            ch prop (car expected) got)
+                    errors)))
+          (setq expected (cdr expected)))))
+    (when errors
+      (ert-fail (mapconcat (lambda (line) line) (nreverse errors) "")))))
 
 
 (defconst casefiddle-tests--characters
@@ -63,13 +67,9 @@
     (?Ł ?Ł ?ł ?Ł)
     (?ł ?Ł ?ł ?Ł)
 
-    ;; FIXME(bug#24603): Commented ones are what we want.
-    ;;(?DŽ ?DŽ ?dž ?Dž)
-    (?DŽ ?DŽ ?dž ?DŽ)
-    ;;(?Dž ?DŽ ?dž ?Dž)
-    (?Dž ?DŽ ?dž ?DŽ)
-    ;;(?dž ?DŽ ?dž ?Dž)
-    (?dž ?DŽ ?dž ?DŽ)
+    (?DŽ ?DŽ ?dž ?Dž)
+    (?Dž ?DŽ ?dž ?Dž)
+    (?dž ?DŽ ?dž ?Dž)
 
     (?Σ ?Σ ?σ ?Σ)
     (?σ ?Σ ?σ ?Σ)
@@ -186,25 +186,25 @@
       ;; input     upper     lower    capitalize up-initials
       '(("Foo baR" "FOO BAR" "foo bar" "Foo Bar" "Foo BaR")
         ("Ⅷ ⅷ" "Ⅷ Ⅷ" "ⅷ ⅷ" "Ⅷ Ⅷ" "Ⅷ Ⅷ")
-        ;; FIXME(bug#24603): Everything below is broken at the moment.
-        ;; Here’s what should happen:
-        ;;("DŽUNGLA" "DŽUNGLA" "džungla" "Džungla" "DžUNGLA")
-        ;;("��ungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
-        ;;("��ungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
-        ;;("define" "DEFINE" "define" "Define" "Define")
-        ;;("fish" "FIsh" "fish" "Fish" "Fish")
-        ;;("Straße" "STRASSE" "straße" "Straße" "Straße")
-        ;;("ΌΣ��Σ" "ΌΣΟΣ" "όσος" "Όσος" "Όσος")
-        ;; And here’s what is actually happening:
-        ("DŽUNGLA" "DŽUNGLA" "džungla" "DŽungla" "DŽUNGLA")
-        ("Džungla" "DŽUNGLA" "džungla" "DŽungla" "DŽungla")
-        ("džungla" "DŽUNGLA" "džungla" "DŽungla" "DŽungla")
-        ("define" "DEfiNE" "define" "Define" "Define")
-        ("fish" "fiSH" "fish" "fish" "fish")
-        ("Straße" "STRAßE" "straße" "Straße" "Straße")
-        ("����ΟΣ" "ΌΣΟΣ" "όσο��" "Όσο��" "Ό��ΟΣ")
-
-        ("όσο��" "ΌΣΟΣ" "όσο��" "Όσο��" "Όσο��"))))))
+        ;; "DžUNGLA" is an unfortunate result but it’s really best we can
+        ;; do while still being consistent.  Hopefully, users only ever
+        ;; use upcase-initials on camelCase identifiers not real words.
+        ("��UNGLA" "DŽUNGLA" "džungla" "Džungla" "DžUNGLA")
+        ("��ungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
+        ("džungla" "DŽUNGLA" "džungla" "Džungla" "Džungla")
+        ("define" "DEFINE" "define" "Define" "Define")
+        ("fish" "FISH" "fish" "Fish" "Fish")
+        ("Stra��e" "STRASSE" "straße" "Straße" "Straße")
+
+        ;; The word repeated twice to test behaviour at the end of a word
+        ;; inside of an input string as well as at the end of the string.
+        ("ΌΣΟΣ ΌΣΟΣ" "ΌΣΟΣ ΌΣΟΣ" "όσος όσος" "Όσος Όσος" "ΌΣΟΣ ΌΣΟΣ")
+        ;; What should be done with sole sigma?  It is ‘final’ but on the
+        ;; other hand it does not form a word.  We’re using regular sigma.
+        ("Σ Σ" "Σ Σ" "σ σ" "Σ Σ" "Σ Σ")
+        ("��σ��ς" "ΌΣΟΣ" "όσο��" "Όσο��" "Όσ��ς")
+        ;; If sigma is already lower case, we don’t want to change it.
+        ("όσο��" "ΌΣΟΣ" "όσο��" "Όσο��" "Όσο��"))))))
 
 (ert-deftest casefiddle-tests-casing-byte8 ()
   (should-not
@@ -243,4 +243,21 @@
                 "\xef\xff\xef Zażółć GĘŚlą \xcf\xcf")))))))
 
 
+(ert-deftest casefiddle-tests-char-casing ()
+  ;;             input upcase downcase [titlecase]
+  (dolist (test '((?a ?A ?a) (?A ?A ?a)
+                  (?ł ?Ł ?ł) (?Ł ?Ł ?ł)
+                  (?ß ?ß ?ß) (?ẞ ?ẞ ?ß)
+                  (?ⅷ ?Ⅷ ?ⅷ) (?Ⅷ ?Ⅷ ?ⅷ)
+                  (?DŽ ?DŽ ?dž ?Dž) (?Dž ?DŽ ?dž ?Dž) (?dž ?DŽ ?dž ?Dž)))
+    (let ((ch (car test))
+          (up (nth 1 test))
+          (lo (nth 2 test))
+          (tc (or (nth 3 test) (nth 1 test))))
+      (should (eq up (upcase ch)))
+      (should (eq lo (downcase ch)))
+      (should (eq tc (capitalize ch)))
+      (should (eq tc (upcase-initials ch))))))
+
+
 ;;; casefiddle-tests.el ends here
diff --git a/test/src/data-tests.el b/test/src/data-tests.el
index 67d00a7f930..00a30559e32 100644
--- a/test/src/data-tests.el
+++ b/test/src/data-tests.el
@@ -22,7 +22,6 @@
 ;;; Code:
 
 (require 'cl-lib)
-(eval-when-compile (require 'cl))
 
 (ert-deftest data-tests-= ()
   (should-error (=))
@@ -141,9 +140,9 @@
       43))))
 
 (defun mock-bool-vector-count-consecutive (a b i)
-  (loop for i from i below (length a)
-        while (eq (aref a i) b)
-        sum 1))
+  (cl-loop for i from i below (length a)
+           while (eq (aref a i) b)
+           sum 1))
 
 (defun test-bool-vector-bv-from-hex-string (desc)
   (let (bv nchars nibbles)
@@ -157,7 +156,7 @@
       (dolist (n (nreverse nibbles))
         (dotimes (_ 4)
           (aset bv i (> (logand 1 n) 0))
-          (incf i)
+          (cl-incf i)
           (setf n (lsh n -1)))))
     bv))
 
@@ -182,9 +181,9 @@ hexadecimal digits describing the bool vector.  We exhaustively
 test all counts at all possible positions in the vector by
 comparing the subr with a much slower lisp implementation."
   (let ((bv (test-bool-vector-bv-from-hex-string desc)))
-    (loop
+    (cl-loop
      for lf in '(nil t)
-     do (loop
+     do (cl-loop
          for pos from 0 upto (length bv)
          for cnt = (mock-bool-vector-count-consecutive bv lf pos)
          for rcnt = (bool-vector-count-consecutive bv lf pos)
@@ -217,36 +216,36 @@ comparing the subr with a much slower lisp implementation."
 (defun test-bool-vector-apply-mock-op (mock a b c)
   "Compute (slowly) the correct result of a bool-vector set operation."
   (let (changed nv)
-    (assert (eql (length b) (length c)))
+    (cl-assert (eql (length b) (length c)))
     (if a (setf nv a)
       (setf a (make-bool-vector (length b) nil))
       (setf changed t))
 
-    (loop for i below (length b)
-          for mockr = (funcall mock
-                               (if (aref b i) 1 0)
-                               (if (aref c i) 1 0))
-          for r = (not (= 0 mockr))
-          do (progn
-               (unless (eq (aref a i) r)
-                 (setf changed t))
-               (setf (aref a i) r)))
+    (cl-loop for i below (length b)
+             for mockr = (funcall mock
+                                  (if (aref b i) 1 0)
+                                  (if (aref c i) 1 0))
+             for r = (not (= 0 mockr))
+             do (progn
+                  (unless (eq (aref a i) r)
+                    (setf changed t))
+                  (setf (aref a i) r)))
     (if changed a)))
 
 (defun test-bool-vector-binop (mock real)
   "Test a binary set operation."
-  (loop for s1 in bool-vector-test-vectors
-        for bv1 = (test-bool-vector-bv-from-hex-string s1)
-        for vecs2 = (cl-remove-if-not
-                     (lambda (x) (eql (length x) (length s1)))
-                     bool-vector-test-vectors)
-        do (loop for s2 in vecs2
-                 for bv2 = (test-bool-vector-bv-from-hex-string s2)
-                 for mock-result = (test-bool-vector-apply-mock-op
-                                    mock nil bv1 bv2)
-                 for real-result = (funcall real bv1 bv2)
-                 do (progn
-                      (should (equal mock-result real-result))))))
+  (cl-loop for s1 in bool-vector-test-vectors
+           for bv1 = (test-bool-vector-bv-from-hex-string s1)
+           for vecs2 = (cl-remove-if-not
+                        (lambda (x) (eql (length x) (length s1)))
+                        bool-vector-test-vectors)
+           do (cl-loop for s2 in vecs2
+                       for bv2 = (test-bool-vector-bv-from-hex-string s2)
+                       for mock-result = (test-bool-vector-apply-mock-op
+                                          mock nil bv1 bv2)
+                       for real-result = (funcall real bv1 bv2)
+                       do (progn
+                            (should (equal mock-result real-result))))))
 
 (ert-deftest bool-vector-intersection-op ()
   (test-bool-vector-binop
@@ -300,8 +299,7 @@ comparing the subr with a much slower lisp implementation."
 
 (ert-deftest binding-test-manual ()
   "A test case from the elisp manual."
-  (save-excursion
-    (set-buffer binding-test-buffer-A)
+  (with-current-buffer binding-test-buffer-A
     (let ((binding-test-some-local 'something-else))
       (should (eq binding-test-some-local 'something-else))
       (set-buffer binding-test-buffer-B)
@@ -312,8 +310,7 @@ comparing the subr with a much slower lisp implementation."
 
 (ert-deftest binding-test-setq-default ()
   "Test that a setq-default has no effect when there is a local binding."
-  (save-excursion
-    (set-buffer binding-test-buffer-B)
+  (with-current-buffer binding-test-buffer-B
     ;; This variable is not local in this buffer.
     (let ((binding-test-some-local 'something-else))
       (setq-default binding-test-some-local 'new-default))
@@ -321,8 +318,7 @@ comparing the subr with a much slower lisp implementation."
 
 (ert-deftest binding-test-makunbound ()
   "Tests of makunbound, from the manual."
-  (save-excursion
-    (set-buffer binding-test-buffer-B)
+  (with-current-buffer binding-test-buffer-B
     (should (boundp 'binding-test-some-local))
     (let ((binding-test-some-local 'outer))
       (let ((binding-test-some-local 'inner))
@@ -342,19 +338,19 @@ comparing the subr with a much slower lisp implementation."
 
 (ert-deftest binding-test-set-constant-t ()
   "Test setting the constant t"
-  (should-error (setq t 'bob) :type 'setting-constant))
+  (with-no-warnings (should-error (setq t 'bob) :type 'setting-constant)))
 
 (ert-deftest binding-test-set-constant-nil ()
   "Test setting the constant nil"
-  (should-error (setq nil 'bob) :type 'setting-constant))
+  (with-no-warnings (should-error (setq nil 'bob) :type 'setting-constant)))
 
 (ert-deftest binding-test-set-constant-keyword ()
   "Test setting a keyword constant"
-  (should-error (setq :keyword 'bob) :type 'setting-constant))
+  (with-no-warnings (should-error (setq :keyword 'bob) :type 'setting-constant)))
 
 (ert-deftest binding-test-set-constant-nil ()
   "Test setting a keyword to itself"
-  (should (setq :keyword :keyword)))
+  (with-no-warnings (should (setq :keyword :keyword))))
 
 ;; More tests to write -
 ;; kill-local-variable
@@ -406,12 +402,14 @@ comparing the subr with a much slower lisp implementation."
                                       (should (null watch-data))))
       ;; Watch var0, then alias it.
       (add-variable-watcher 'data-tests-var0 collect-watch-data)
+      (defvar data-tests-var0-alias)
       (defvaralias 'data-tests-var0-alias 'data-tests-var0)
       (setq data-tests-var0 1)
       (should-have-watch-data '(data-tests-var0 1 set nil))
       (setq data-tests-var0-alias 2)
       (should-have-watch-data '(data-tests-var0 2 set nil))
       ;; Alias var1, then watch var1-alias.
+      (defvar data-tests-var1-alias)
       (defvaralias 'data-tests-var1-alias 'data-tests-var1)
       (add-variable-watcher 'data-tests-var1-alias collect-watch-data)
       (setq data-tests-var1 1)
@@ -419,6 +417,7 @@ comparing the subr with a much slower lisp implementation."
       (setq data-tests-var1-alias 2)
       (should-have-watch-data '(data-tests-var1 2 set nil))
       ;; Alias var2, then watch it.
+      (defvar data-tests-var2-alias)
       (defvaralias 'data-tests-var2-alias 'data-tests-var2)
       (add-variable-watcher 'data-tests-var2 collect-watch-data)
       (setq data-tests-var2 1)
@@ -437,7 +436,8 @@ comparing the subr with a much slower lisp implementation."
       (should (null watch-data)))))
 
 (ert-deftest data-tests-local-variable-watchers ()
-  (defvar-local data-tests-lvar 0)
+  (with-no-warnings
+    (defvar-local data-tests-lvar 0))
   (let* ((buf1 (current-buffer))
          (buf2 nil)
          (watch-data nil)
diff --git a/test/src/editfns-tests.el b/test/src/editfns-tests.el
index 14124ef85fb..a3ea8ab60b5 100644
--- a/test/src/editfns-tests.el
+++ b/test/src/editfns-tests.el
@@ -136,4 +136,107 @@
 (ert-deftest format-c-float ()
   (should-error (format "%c" 0.5)))
 
+;;; Check format-time-string with various TZ settings.
+;;; Use only POSIX-compatible TZ values, since the tests should work
+;;; even if tzdb is not in use.
+(ert-deftest format-time-string-with-zone ()
+  ;; Don’t use (0 0 0 0) as the test case, as there are too many bugs
+  ;; in MS-Windows (and presumably other) C libraries when formatting
+  ;; time stamps near the Epoch of 1970-01-01 00:00:00 UTC, and this
+  ;; test is for GNU Emacs, not for C runtimes.  Instead, look before
+  ;; you leap: "look" is the timestamp just before the first leap
+  ;; second on 1972-06-30 23:59:60 UTC, so it should format to the
+  ;; same string regardless of whether the underlying C library
+  ;; ignores leap seconds, while avoiding circa-1970 glitches.
+  ;;
+  ;; Similarly, stick to the limited set of time zones that are
+  ;; supported by both POSIX and MS-Windows: exactly 3 ASCII letters
+  ;; in the abbreviation, and no DST.
+  (let ((look '(1202 22527 999999 999999))
+        (format "%Y-%m-%d %H:%M:%S.%3N %z (%Z)"))
+    ;; UTC.
+    (should (string-equal
+             (format-time-string "%Y-%m-%d %H:%M:%S.%3N %z" look t)
+             "1972-06-30 23:59:59.999 +0000"))
+    ;; "UTC0".
+    (should (string-equal
+             (format-time-string format look "UTC0")
+             "1972-06-30 23:59:59.999 +0000 (UTC)"))
+    ;; Negative UTC offset, as a Lisp list.
+    (should (string-equal
+             (format-time-string format look '(-28800 "PST"))
+             "1972-06-30 15:59:59.999 -0800 (PST)"))
+    ;; Positive UTC offset that is not an hour multiple, as a string.
+    (should (string-equal
+             (format-time-string format look "IST-5:30")
+             "1972-07-01 05:29:59.999 +0530 (IST)"))))
+
+;;; This should not dump core.
+(ert-deftest format-time-string-with-outlandish-zone ()
+  (should (stringp
+           (format-time-string "%Y-%m-%d %H:%M:%S.%3N %z" nil
+                               (concat (make-string 2048 ?X) "0")))))
+
+(ert-deftest format-with-field ()
+  (should (equal (format "First argument %2$s, then %3$s, then %1$s" 1 2 3)
+                 "First argument 2, then 3, then 1"))
+  (should (equal (format "a %2$s %3$d %1$d %2$S %3$d %4$d b" 11 "22" 33 44)
+                 "a 22 33 11 \"22\" 33 44 b"))
+  (should (equal (format "a %08$s %0000000000000000009$s b" 1 2 3 4 5 6 7 8 9)
+                 "a 8 9 b"))
+  (should (equal (should-error (format "a %999999$s b" 11))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %2147483647$s b"))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %9223372036854775807$s b"))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %9223372036854775808$s b"))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %18446744073709551615$s b"))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %18446744073709551616$s b"))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error
+                  (format (format "a %%%d$d b" most-positive-fixnum)))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error
+                  (format (format "a %%%d$d b" (+ 1.0 most-positive-fixnum))))
+                 '(error "Not enough arguments for format string")))
+  (should (equal (should-error (format "a %$s b" 11))
+                 '(error "Invalid format operation %$")))
+  (should (equal (should-error (format "a %-1$s b" 11))
+                 '(error "Invalid format operation %$")))
+  (should (equal (format "%1$c %1$s" ?±) "± 177")))
+
+(ert-deftest replace-buffer-contents-1 ()
+  (with-temp-buffer
+    (insert #("source" 2 4 (prop 7)))
+    (let ((source (current-buffer)))
+      (with-temp-buffer
+        (insert "before dest after")
+        (let ((marker (set-marker (make-marker) 14)))
+          (save-restriction
+            (narrow-to-region 8 12)
+            (replace-buffer-contents source))
+          (should (equal (marker-buffer marker) (current-buffer)))
+          (should (equal (marker-position marker) 16)))
+        (should (equal-including-properties
+                 (buffer-string)
+                 #("before source after" 9 11 (prop 7))))
+        (should (equal (point) 9))))
+    (should (equal-including-properties
+             (buffer-string)
+             #("source" 2 4 (prop 7))))))
+
+(ert-deftest replace-buffer-contents-2 ()
+  (with-temp-buffer
+    (insert "foo bar baz qux")
+    (let ((source (current-buffer)))
+      (with-temp-buffer
+        (insert "foo BAR baz qux")
+        (replace-buffer-contents source)
+        (should (equal-including-properties
+                 (buffer-string)
+                 "foo bar baz qux"))))))
+
 ;;; editfns-tests.el ends here
diff --git a/test/src/emacs-module-tests.el b/test/src/emacs-module-tests.el
new file mode 100644
index 00000000000..a4994b6223b
--- /dev/null
+++ b/test/src/emacs-module-tests.el
@@ -0,0 +1,218 @@
+;;; Test GNU Emacs modules.
+
+;; Copyright 2015-2017 Free Software Foundation, Inc.
+
+;; 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/>.  */
+
+(require 'ert)
+
+(defconst mod-test-emacs
+  (expand-file-name invocation-name invocation-directory)
+  "File name of the Emacs binary currently running.")
+
+(eval-and-compile
+  (defconst mod-test-file
+    (substitute-in-file-name
+     "$EMACS_TEST_DIRECTORY/data/emacs-module/mod-test")
+    "File name of the module test file."))
+
+(require 'mod-test mod-test-file)
+
+;;
+;; Basic tests.
+;;
+
+(ert-deftest mod-test-sum-test ()
+  (should (= (mod-test-sum 1 2) 3))
+  (let ((descr (should-error (mod-test-sum 1 2 3))))
+    (should (eq (car descr) 'wrong-number-of-arguments))
+    (should (module-function-p (nth 1 descr)))
+    (should (eq 0
+                (string-match
+                 (concat "#<module function "
+                         "\\(at \\(0x\\)?[0-9a-fA-F]+\\( from .*\\)?"
+                         "\\|Fmod_test_sum from .*\\)>")
+                 (prin1-to-string (nth 1 descr)))))
+    (should (= (nth 2 descr) 3)))
+  (should-error (mod-test-sum "1" 2) :type 'wrong-type-argument)
+  (should-error (mod-test-sum 1 "2") :type 'wrong-type-argument)
+  ;; The following tests are for 32-bit build --with-wide-int.
+  (should (= (mod-test-sum -1 most-positive-fixnum)
+             (1- most-positive-fixnum)))
+  (should (= (mod-test-sum 1 most-negative-fixnum)
+             (1+ most-negative-fixnum)))
+  (when (< #x1fffffff most-positive-fixnum)
+    (should (= (mod-test-sum 1 #x1fffffff)
+               (1+ #x1fffffff)))
+    (should (= (mod-test-sum -1 #x20000000)
+               #x1fffffff)))
+  (should-error (mod-test-sum 1 most-positive-fixnum)
+                :type 'overflow-error)
+  (should-error (mod-test-sum -1 most-negative-fixnum)
+                :type 'overflow-error))
+
+(ert-deftest mod-test-sum-docstring ()
+  (should (string= (documentation 'mod-test-sum) "Return A + B\n\n(fn a b)")))
+
+(ert-deftest module-function-object ()
+  "Extract and test the implementation of a module function.
+This test needs to be changed whenever the implementation
+changes."
+  (let ((func (symbol-function #'mod-test-sum)))
+    (should (module-function-p func))
+    (should (equal (type-of func) 'module-function))
+    (should (string-match-p
+             (rx bos "#<module function "
+                 (or "Fmod_test_sum"
+                     (and "at 0x" (+ hex-digit)))
+                 (? " from " (* nonl) "mod-test" (* nonl) )
+                 ">" eos)
+             (prin1-to-string func)))))
+
+;;
+;; Non-local exists (throw, signal).
+;;
+
+(ert-deftest mod-test-non-local-exit-signal-test ()
+  (should-error (mod-test-signal))
+  (let (debugger-args backtrace)
+    (should-error
+     (let ((debugger (lambda (&rest args)
+                       (setq debugger-args args
+                             backtrace (with-output-to-string (backtrace)))
+                       (cl-incf num-nonmacro-input-events)))
+           (debug-on-signal t))
+       (mod-test-signal)))
+    (should (equal debugger-args '(error (error . 56))))
+    (should (string-match-p
+             (rx bol "  mod-test-signal()" eol)
+             backtrace))))
+
+(ert-deftest mod-test-non-local-exit-throw-test ()
+  (should (equal
+           (catch 'tag
+             (mod-test-throw)
+             (ert-fail "expected throw"))
+           65)))
+
+(ert-deftest mod-test-non-local-exit-funcall-normal ()
+  (should (equal (mod-test-non-local-exit-funcall (lambda () 23))
+                 23)))
+
+(ert-deftest mod-test-non-local-exit-funcall-signal ()
+  (should (equal (mod-test-non-local-exit-funcall
+                  (lambda () (signal 'error '(32))))
+                 '(signal error (32)))))
+
+(ert-deftest mod-test-non-local-exit-funcall-throw ()
+  (should (equal (mod-test-non-local-exit-funcall (lambda () (throw 'tag 32)))
+                 '(throw tag 32))))
+
+;;
+;; String tests.
+;;
+
+(defun multiply-string (s n)
+  (let ((res ""))
+    (dotimes (i n res)
+      (setq res (concat res s)))))
+
+(ert-deftest mod-test-globref-make-test ()
+  (let ((mod-str (mod-test-globref-make))
+        (ref-str (multiply-string "abcdefghijklmnopqrstuvwxyz" 100)))
+    (garbage-collect) ;; XXX: not enough to really test but it's something..
+    (should (string= ref-str mod-str))))
+
+(ert-deftest mod-test-string-a-to-b-test ()
+  (should (string= (mod-test-string-a-to-b "aaa") "bbb")))
+
+;;
+;; User-pointer tests.
+;;
+
+(ert-deftest mod-test-userptr-fun-test ()
+  (let* ((n 42)
+         (v (mod-test-userptr-make n))
+         (r (mod-test-userptr-get v)))
+
+    (should (eq (type-of v) 'user-ptr))
+    (should (integerp r))
+    (should (= r n))))
+
+;; TODO: try to test finalizer
+
+;;
+;; Vector tests.
+;;
+
+(ert-deftest mod-test-vector-test ()
+  (dolist (s '(2 10 100 1000))
+    (dolist (e '(42 foo "foo"))
+      (let* ((v-ref (make-vector 2 e))
+             (eq-ref (eq (aref v-ref 0) (aref v-ref 1)))
+             (v-test (make-vector s nil)))
+
+        (should (eq (mod-test-vector-fill v-test e) t))
+        (should (eq (mod-test-vector-eq v-test e) eq-ref))))))
+
+(ert-deftest module--func-arity ()
+  (should (equal (func-arity #'mod-test-return-t) '(1 . 1)))
+  (should (equal (func-arity #'mod-test-sum) '(2 . 2))))
+
+(ert-deftest module--help-function-arglist ()
+  (should (equal (help-function-arglist #'mod-test-return-t :preserve-names)
+                 '(arg1)))
+  (should (equal (help-function-arglist #'mod-test-return-t)
+                 '(arg1)))
+  (should (equal (help-function-arglist #'mod-test-sum :preserve-names)
+                 '(a b)))
+  (should (equal (help-function-arglist #'mod-test-sum)
+                 '(arg1 arg2))))
+
+(ert-deftest module--test-assertions ()
+  "Check that -module-assertions work."
+  (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))))
+
+;;; emacs-module-tests.el ends here
diff --git a/test/src/eval-tests.el b/test/src/eval-tests.el
index 95655eac826..03f408716b1 100644
--- a/test/src/eval-tests.el
+++ b/test/src/eval-tests.el
@@ -32,6 +32,8 @@
   ;; This should not crash.
   (should-error (funcall '(closure)) :type 'invalid-function))
 
+(defvar byte-compile-debug)
+
 (ert-deftest eval-tests--bugs-24912-and-24913 ()
   "Checks that Emacs doesn’t accept weird argument lists.
 Bug#24912 and Bug#24913."
diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el
index a1b48a643e1..2e463455f0c 100644
--- a/test/src/fns-tests.el
+++ b/test/src/fns-tests.el
@@ -22,7 +22,6 @@
 ;;; Code:
 
 (require 'cl-lib)
-(eval-when-compile (require 'cl))
 
 (ert-deftest fns-tests-reverse ()
   (should-error (reverse))
diff --git a/test/src/lread-tests.el b/test/src/lread-tests.el
index a783afd3128..98cbb6a301d 100644
--- a/test/src/lread-tests.el
+++ b/test/src/lread-tests.el
@@ -112,4 +112,56 @@
   (should-error (read "#24r") :type 'invalid-read-syntax)
   (should-error (read "#") :type 'invalid-read-syntax))
 
+(ert-deftest lread-record-1 ()
+  (should (equal '(#s(foo) #s(foo))
+                 (read "(#1=#s(foo) #1#)"))))
+
+(defmacro lread-tests--with-temp-file (file-name-var &rest body)
+  (declare (indent 1))
+  (cl-check-type file-name-var symbol)
+  `(let ((,file-name-var (make-temp-file "emacs")))
+     (unwind-protect
+         (progn ,@body)
+       (delete-file ,file-name-var))))
+
+(defun lread-tests--last-message ()
+  (with-current-buffer "*Messages*"
+    (save-excursion
+      (goto-char (point-max))
+      (skip-chars-backward "\n")
+      (buffer-substring (line-beginning-position) (point)))))
+
+(ert-deftest lread-tests--unescaped-char-literals ()
+  "Check that loading warns about unescaped character
+literals (Bug#20852)."
+  (lread-tests--with-temp-file file-name
+    (write-region "?) ?( ?; ?\" ?[ ?]" nil file-name)
+    (should (equal (load file-name nil :nomessage :nosuffix) t))
+    (should (equal (lread-tests--last-message)
+                   (concat (format-message "Loading `%s': " file-name)
+                           "unescaped character literals "
+                           "`?\"', `?(', `?)', `?;', `?[', `?]' detected!")))))
+
+(ert-deftest lread-test-bug26837 ()
+  "Test for http://debbugs.gnu.org/26837 ."
+  (let ((load-path (cons
+                    (file-name-as-directory
+                     (expand-file-name "data" (getenv "EMACS_TEST_DIRECTORY")))
+                    load-path)))
+    (load "somelib" nil t)
+    (should (string-suffix-p "/somelib.el" (caar load-history)))
+    (load "somelib2" nil t)
+    (should (string-suffix-p "/somelib2.el" (caar load-history)))
+    (load "somelib" nil t)
+    (should (string-suffix-p "/somelib.el" (caar load-history)))))
+
+(ert-deftest lread-tests--old-style-backquotes ()
+  "Check that loading warns about old-style backquotes."
+  (lread-tests--with-temp-file file-name
+    (write-region "(` (a b))" nil file-name)
+    (should (equal (load file-name nil :nomessage :nosuffix) t))
+    (should (equal (lread-tests--last-message)
+                   (concat (format-message "Loading `%s': " file-name)
+                           "old-style backquotes detected!")))))
+
 ;;; lread-tests.el ends here
diff --git a/test/src/regex-tests.el b/test/src/regex-tests.el
index db187fd4a6a..1364bf6848a 100644
--- a/test/src/regex-tests.el
+++ b/test/src/regex-tests.el
@@ -424,7 +424,7 @@ differences in behavior.")
   (let (failures
         basic icase notbol noteol)
     (regex-tests-generic-line
-     ?; "BOOST.tests" regex-tests-BOOST-whitelist
+     ?\; "BOOST.tests" regex-tests-BOOST-whitelist
      (if (save-excursion (re-search-forward "^-" nil t))
          (setq basic   (save-excursion (re-search-forward "REG_BASIC" nil t))
                icase   (save-excursion (re-search-forward "REG_ICASE" nil t))
diff --git a/test/src/undo-tests.el b/test/src/undo-tests.el
index fbd3bf84a42..0cf7fc9f59c 100644
--- a/test/src/undo-tests.el
+++ b/test/src/undo-tests.el
@@ -444,5 +444,27 @@ Demonstrates bug 16818."
       (ert-run-tests-interactively "^undo-")
     (ert-run-tests-batch "^undo-")))
 
+(ert-deftest undo-test-skip-invalidated-markers ()
+  "Test marker adjustment when the marker points nowhere.
+Demonstrates bug 25599."
+  (with-temp-buffer
+    (buffer-enable-undo)
+    (insert ";; aaaaaaaaa
+;; bbbbbbbb")
+    (let ((overlay-modified
+           (lambda (ov after-p _beg _end &optional length)
+             (unless after-p
+               (when (overlay-buffer ov)
+                 (delete-overlay ov))))))
+      (save-excursion
+        (goto-char (point-min))
+        (let ((ov (make-overlay (line-beginning-position 2)
+                                (line-end-position 2))))
+          (overlay-put ov 'insert-in-front-hooks
+                       (list overlay-modified)))))
+    (kill-region (point-min) (line-beginning-position 2))
+    (undo-boundary)
+    (undo)))
+
 (provide 'undo-tests)
 ;;; undo-tests.el ends here