Merge branch 'master' into feature/byte-switch

3 files changed, 388 insertions, 0 deletions

diff --git a/test/lisp/filenotify-tests.el b/test/lisp/filenotify-tests.el
index 27434bcef20..dcd83a3ef3b 100644
--- a/test/lisp/filenotify-tests.el
+++ b/test/lisp/filenotify-tests.el
@@ -676,6 +676,9 @@ delivered."
         buf)
     (unwind-protect
         (progn
+          ;; In the remote case, `vc-refresh-state' returns undesired
+          ;; error messages.  Let's suppress them.
+          (advice-add 'vc-refresh-state :around 'ignore)
           (setq file-notify--test-tmpfile (file-notify--test-make-temp-name))
           (write-region
            "any text" nil file-notify--test-tmpfile nil 'no-message)
@@ -745,6 +748,7 @@ delivered."
           (file-notify--test-cleanup-p))
 
       ;; Cleanup.
+      (advice-remove 'vc-refresh-state 'ignore)
       (ignore-errors (kill-buffer buf))
       (file-notify--test-cleanup))))
 
diff --git a/test/lisp/progmodes/bat-mode-tests.el b/test/lisp/progmodes/bat-mode-tests.el
new file mode 100644
index 00000000000..565718eea41
--- /dev/null
+++ b/test/lisp/progmodes/bat-mode-tests.el
@@ -0,0 +1,86 @@
+;;; bat-mode-tests.el --- Tests for bat-mode.el  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2017 Free Software Foundation, Inc.
+
+;; Author: Vladimir Panteleev <vladimir@thecybershadow.net>
+;; Keywords:
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;
+
+;;; Code:
+
+(require 'ert)
+(require 'bat-mode)
+(require 'htmlfontify)
+
+(defun bat-test-fontify (str)
+  "Fontify STR in `bat-mode' to a HTML string using `htmlfontify' and return it."
+  (with-temp-buffer
+    (insert str)
+    (bat-mode)
+    (let ((hfy-optimizations '(body-text-only merge-adjacent-tags)))
+      (with-current-buffer (htmlfontify-buffer) (buffer-string)))))
+
+(ert-deftest bat-test-fontification-var-decl ()
+  "Test fontification of variable declarations."
+  (should
+   (equal
+    (bat-test-fontify "set a_b-c{d}e=f")
+    "<span class=\"builtin\">set</span> <span class=\"variable-name\">a_b-c{d}e</span>=f")))
+
+(ert-deftest bat-test-fontification-var-exp ()
+  "Test fontification of variable expansions."
+  (should
+   (equal
+    (bat-test-fontify "echo %a_b-c{d}e%")
+    "<span class=\"builtin\">echo</span> %<span class=\"variable-name\">a_b-c{d}e</span>%")))
+
+(ert-deftest bat-test-fontification-var-delayed-exp ()
+  "Test fontification of delayed variable expansions."
+  (should
+   (equal
+    (bat-test-fontify "echo !a_b-c{d}e!")
+    "<span class=\"builtin\">echo</span> !<span class=\"variable-name\">a_b-c{d}e</span>!")))
+
+(ert-deftest bat-test-fontification-iter-var-1 ()
+  "Test fontification of iteration variables."
+  (should
+   (equal
+    (bat-test-fontify "echo %%a\necho %%~dp1\necho %%~$PATH:I")
+    "<span class=\"builtin\">echo</span> %%<span class=\"variable-name\">a</span>
+<span class=\"builtin\">echo</span> %%~dp<span class=\"variable-name\">1</span>
+<span class=\"builtin\">echo</span> %%~$<span class=\"variable-name\">PATH</span>:<span class=\"variable-name\">I</span>")))
+
+(defun bat-test-fill-paragraph (str)
+  "Return the result of invoking `fill-paragraph' on STR in a `bat-mode' buffer."
+  (with-temp-buffer
+    (bat-mode)
+    (insert str)
+    (goto-char 1)
+    (font-lock-ensure)
+    (fill-paragraph)
+    (buffer-string)))
+
+(ert-deftest bat-test-fill-paragraph-comment ()
+  "Test `fill-paragraph' in a comment block."
+  (should (equal (bat-test-fill-paragraph "rem foo\nrem bar\n") "rem foo bar\n")))
+
+(provide 'bat-tests)
+;;; bat-mode-tests.el ends here
diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el
index ee3c5dc77e4..160d0f106e9 100644
--- a/test/src/fns-tests.el
+++ b/test/src/fns-tests.el
@@ -245,3 +245,301 @@
   (let ((data '((foo) (bar))))
     (should (equal (mapcan #'identity data) '(foo bar)))
     (should (equal data                     '((foo bar) (bar))))))
+
+;; Test handling of cyclic and dotted lists.
+
+(defun cyc1 (a)
+  (let ((ls (make-list 10 a)))
+    (nconc ls ls)
+    ls))
+
+(defun cyc2 (a b)
+  (let ((ls1 (make-list 10 a))
+        (ls2 (make-list 1000 b)))
+    (nconc ls2 ls2)
+    (nconc ls1 ls2)
+    ls1))
+
+(defun dot1 (a)
+  (let ((ls (make-list 10 a)))
+    (nconc ls 'tail)
+    ls))
+
+(defun dot2 (a b)
+  (let ((ls1 (make-list 10 a))
+        (ls2 (make-list 10 b)))
+    (nconc ls1 ls2)
+    (nconc ls2 'tail)
+    ls1))
+
+(ert-deftest test-cycle-length ()
+  (should-error (length (cyc1 1)) :type 'circular-list)
+  (should-error (length (cyc2 1 2)) :type 'circular-list)
+  (should-error (length (dot1 1)) :type 'wrong-type-argument)
+  (should-error (length (dot2 1 2)) :type 'wrong-type-argument))
+
+(ert-deftest test-cycle-safe-length ()
+  (should (<= 10 (safe-length (cyc1 1))))
+  (should (<= 1010 (safe-length (cyc2 1 2))))
+  (should (= 10 (safe-length (dot1 1))))
+  (should (= 20 (safe-length (dot2 1 2)))))
+
+(ert-deftest test-cycle-member ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (member 1 c1))
+    (should (member 1 c2))
+    (should (member 1 d1))
+    (should (member 1 d2))
+    (should-error (member 2 c1) :type 'circular-list)
+    (should (member 2 c2))
+    (should-error (member 2 d1) :type 'wrong-type-argument)
+    (should (member 2 d2))
+    (should-error (member 3 c1) :type 'circular-list)
+    (should-error (member 3 c2) :type 'circular-list)
+    (should-error (member 3 d1) :type 'wrong-type-argument)
+    (should-error (member 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-memq ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (memq 1 c1))
+    (should (memq 1 c2))
+    (should (memq 1 d1))
+    (should (memq 1 d2))
+    (should-error (memq 2 c1) :type 'circular-list)
+    (should (memq 2 c2))
+    (should-error (memq 2 d1) :type 'wrong-type-argument)
+    (should (memq 2 d2))
+    (should-error (memq 3 c1) :type 'circular-list)
+    (should-error (memq 3 c2) :type 'circular-list)
+    (should-error (memq 3 d1) :type 'wrong-type-argument)
+    (should-error (memq 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-memql ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (memql 1 c1))
+    (should (memql 1 c2))
+    (should (memql 1 d1))
+    (should (memql 1 d2))
+    (should-error (memql 2 c1) :type 'circular-list)
+    (should (memql 2 c2))
+    (should-error (memql 2 d1) :type 'wrong-type-argument)
+    (should (memql 2 d2))
+    (should-error (memql 3 c1) :type 'circular-list)
+    (should-error (memql 3 c2) :type 'circular-list)
+    (should-error (memql 3 d1) :type 'wrong-type-argument)
+    (should-error (memql 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-assq ()
+  (let ((c1 (cyc1 '(1)))
+        (c2 (cyc2 '(1) '(2)))
+        (d1 (dot1 '(1)))
+        (d2 (dot2 '(1) '(2))))
+    (should (assq 1 c1))
+    (should (assq 1 c2))
+    (should (assq 1 d1))
+    (should (assq 1 d2))
+    (should-error (assq 2 c1) :type 'circular-list)
+    (should (assq 2 c2))
+    (should-error (assq 2 d1) :type 'wrong-type-argument)
+    (should (assq 2 d2))
+    (should-error (assq 3 c1) :type 'circular-list)
+    (should-error (assq 3 c2) :type 'circular-list)
+    (should-error (assq 3 d1) :type 'wrong-type-argument)
+    (should-error (assq 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-assoc ()
+  (let ((c1 (cyc1 '(1)))
+        (c2 (cyc2 '(1) '(2)))
+        (d1 (dot1 '(1)))
+        (d2 (dot2 '(1) '(2))))
+    (should (assoc 1 c1))
+    (should (assoc 1 c2))
+    (should (assoc 1 d1))
+    (should (assoc 1 d2))
+    (should-error (assoc 2 c1) :type 'circular-list)
+    (should (assoc 2 c2))
+    (should-error (assoc 2 d1) :type 'wrong-type-argument)
+    (should (assoc 2 d2))
+    (should-error (assoc 3 c1) :type 'circular-list)
+    (should-error (assoc 3 c2) :type 'circular-list)
+    (should-error (assoc 3 d1) :type 'wrong-type-argument)
+    (should-error (assoc 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-rassq ()
+  (let ((c1 (cyc1 '(0 . 1)))
+        (c2 (cyc2 '(0 . 1) '(0 . 2)))
+        (d1 (dot1 '(0 . 1)))
+        (d2 (dot2 '(0 . 1) '(0 . 2))))
+    (should (rassq 1 c1))
+    (should (rassq 1 c2))
+    (should (rassq 1 d1))
+    (should (rassq 1 d2))
+    (should-error (rassq 2 c1) :type 'circular-list)
+    (should (rassq 2 c2))
+    (should-error (rassq 2 d1) :type 'wrong-type-argument)
+    (should (rassq 2 d2))
+    (should-error (rassq 3 c1) :type 'circular-list)
+    (should-error (rassq 3 c2) :type 'circular-list)
+    (should-error (rassq 3 d1) :type 'wrong-type-argument)
+    (should-error (rassq 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-rassoc ()
+  (let ((c1 (cyc1 '(0 . 1)))
+        (c2 (cyc2 '(0 . 1) '(0 . 2)))
+        (d1 (dot1 '(0 . 1)))
+        (d2 (dot2 '(0 . 1) '(0 . 2))))
+    (should (rassoc 1 c1))
+    (should (rassoc 1 c2))
+    (should (rassoc 1 d1))
+    (should (rassoc 1 d2))
+    (should-error (rassoc 2 c1) :type 'circular-list)
+    (should (rassoc 2 c2))
+    (should-error (rassoc 2 d1) :type 'wrong-type-argument)
+    (should (rassoc 2 d2))
+    (should-error (rassoc 3 c1) :type 'circular-list)
+    (should-error (rassoc 3 c2) :type 'circular-list)
+    (should-error (rassoc 3 d1) :type 'wrong-type-argument)
+    (should-error (rassoc 3 d2) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-delq ()
+  (should-error (delq 1 (cyc1 1)) :type 'circular-list)
+  (should-error (delq 1 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delq 1 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delq 1 (dot2 1 2)) :type 'wrong-type-argument)
+  (should-error (delq 2 (cyc1 1)) :type 'circular-list)
+  (should-error (delq 2 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delq 2 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delq 2 (dot2 1 2)) :type 'wrong-type-argument)
+  (should-error (delq 3 (cyc1 1)) :type 'circular-list)
+  (should-error (delq 3 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delq 3 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delq 3 (dot2 1 2)) :type 'wrong-type-argument))
+
+(ert-deftest test-cycle-delete ()
+  (should-error (delete 1 (cyc1 1)) :type 'circular-list)
+  (should-error (delete 1 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delete 1 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delete 1 (dot2 1 2)) :type 'wrong-type-argument)
+  (should-error (delete 2 (cyc1 1)) :type 'circular-list)
+  (should-error (delete 2 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delete 2 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delete 2 (dot2 1 2)) :type 'wrong-type-argument)
+  (should-error (delete 3 (cyc1 1)) :type 'circular-list)
+  (should-error (delete 3 (cyc2 1 2)) :type 'circular-list)
+  (should-error (delete 3 (dot1 1)) :type 'wrong-type-argument)
+  (should-error (delete 3 (dot2 1 2)) :type 'wrong-type-argument))
+
+(ert-deftest test-cycle-reverse ()
+  (should-error (reverse (cyc1 1)) :type 'circular-list)
+  (should-error (reverse (cyc2 1 2)) :type 'circular-list)
+  (should-error (reverse (dot1 1)) :type 'wrong-type-argument)
+  (should-error (reverse (dot2 1 2)) :type 'wrong-type-argument))
+
+(ert-deftest test-cycle-plist-get ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (plist-get c1 1))
+    (should (plist-get c2 1))
+    (should (plist-get d1 1))
+    (should (plist-get d2 1))
+    (should-not (plist-get c1 2))
+    (should (plist-get c2 2))
+    (should-not (plist-get d1 2))
+    (should (plist-get d2 2))
+    (should-not (plist-get c1 3))
+    (should-not (plist-get c2 3))
+    (should-not (plist-get d1 3))
+    (should-not (plist-get d2 3))))
+
+(ert-deftest test-cycle-lax-plist-get ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (lax-plist-get c1 1))
+    (should (lax-plist-get c2 1))
+    (should (lax-plist-get d1 1))
+    (should (lax-plist-get d2 1))
+    (should-error (lax-plist-get c1 2) :type 'circular-list)
+    (should (lax-plist-get c2 2))
+    (should-not (lax-plist-get d1 2))
+    (should (lax-plist-get d2 2))
+    (should-error (lax-plist-get c1 3) :type 'circular-list)
+    (should-error (lax-plist-get c2 3) :type 'circular-list)
+    (should-not (lax-plist-get d1 3))
+    (should-not (lax-plist-get d2 3))))
+
+(ert-deftest test-cycle-plist-member ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (plist-member c1 1))
+    (should (plist-member c2 1))
+    (should (plist-member d1 1))
+    (should (plist-member d2 1))
+    (should-error (plist-member c1 2) :type 'circular-list)
+    (should (plist-member c2 2))
+    (should-error (plist-member d1 2) :type 'wrong-type-argument)
+    (should (plist-member d2 2))
+    (should-error (plist-member c1 3) :type 'circular-list)
+    (should-error (plist-member c2 3) :type 'circular-list)
+    (should-error (plist-member d1 3) :type 'wrong-type-argument)
+    (should-error (plist-member d2 3) :type 'wrong-type-argument)))
+
+(ert-deftest test-cycle-plist-put ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (plist-put c1 1 1))
+    (should (plist-put c2 1 1))
+    (should (plist-put d1 1 1))
+    (should (plist-put d2 1 1))
+    (should-error (plist-put c1 2 2) :type 'circular-list)
+    (should (plist-put c2 2 2))
+    (should (plist-put d1 2 2))
+    (should (plist-put d2 2 2))
+    (should-error (plist-put c1 3 3) :type 'circular-list)
+    (should-error (plist-put c2 3 3) :type 'circular-list)
+    (should (plist-put d1 3 3))
+    (should (plist-put d2 3 3))))
+
+(ert-deftest test-cycle-lax-plist-put ()
+  (let ((c1 (cyc1 1))
+        (c2 (cyc2 1 2))
+        (d1 (dot1 1))
+        (d2 (dot2 1 2)))
+    (should (lax-plist-put c1 1 1))
+    (should (lax-plist-put c2 1 1))
+    (should (lax-plist-put d1 1 1))
+    (should (lax-plist-put d2 1 1))
+    (should-error (lax-plist-put c1 2 2) :type 'circular-list)
+    (should (lax-plist-put c2 2 2))
+    (should (lax-plist-put d1 2 2))
+    (should (lax-plist-put d2 2 2))
+    (should-error (lax-plist-put c1 3 3) :type 'circular-list)
+    (should-error (lax-plist-put c2 3 3) :type 'circular-list)
+    (should (lax-plist-put d1 3 3))
+    (should (lax-plist-put d2 3 3))))
+
+(ert-deftest test-cycle-equal ()
+  (should-error (equal (cyc1 1) (cyc1 1)))
+  (should-error (equal (cyc2 1 2) (cyc2 1 2))))
+
+(ert-deftest test-cycle-nconc ()
+  (should-error (nconc (cyc1 1) 'tail) :type 'circular-list)
+  (should-error (nconc (cyc2 1 2) 'tail) :type 'circular-list))
+
+(provide 'fns-tests)