Make 'eval' use lexical scoping in most tests

* test/lisp/electric-tests.el (electric-pair-define-test-form)
(define-electric-pair-test):
* test/lisp/emacs-lisp/backtrace-tests.el
(backtrace-tests--uncompiled-functions):
* test/lisp/emacs-lisp/cl-macs-tests.el
(cl-macs-test--symbol-macrolet):
* test/lisp/emacs-lisp/let-alist-tests.el
(let-alist-list-to-sexp):
* test/lisp/emacs-lisp/lisp-tests.el
(elisp-tests-with-temp-buffer, core-elisp-tests-3-backquote):
* test/lisp/emacs-lisp/testcover-resources/testcases.el
(testcover-testcase-nth-case):
* test/lisp/ffap-tests.el (ffap-ido-mode):
* test/lisp/files-tests.el (file-test--do-local-variables-test):
* test/lisp/net/tramp-tests.el (tramp--test-utf8):
* test/lisp/progmodes/elisp-mode-tests.el
(find-defs-defgeneric-eval, find-defs-defun-eval)
(find-defs-defvar-eval, find-defs-face-eval)
(find-defs-feature-eval): Give 'eval' non-nil LEXICAL argument.
* test/lisp/subr-tests.el
(subr-tests--dolist--wrong-number-of-args):
* test/src/eval-tests.el (eval-tests--if-dot-string)
(eval-tests--mutating-cond)
(eval-tests-19790-backquote-comma-dot-substitution): Test 'eval'
using LEXICAL as both nil and non-nil.
(eval-tests--let-with-circular-defs): Give explicit nil to 'eval'.

1 files changed, 11 insertions, 6 deletions

diff --git a/test/src/eval-tests.el b/test/src/eval-tests.el
index 4f05d99136b..727c98aa5fa 100644
--- a/test/src/eval-tests.el
+++ b/test/src/eval-tests.el
@@ -86,23 +86,27 @@ Bug#24912."
 
 (ert-deftest eval-tests--if-dot-string ()
   "Check that Emacs rejects (if . \"string\")."
-  (should-error (eval '(if . "abc")) :type 'wrong-type-argument)
+  (should-error (eval '(if . "abc") nil) :type 'wrong-type-argument)
+  (should-error (eval '(if . "abc") t) :type 'wrong-type-argument)
   (let ((if-tail (list '(setcdr if-tail "abc") t)))
-    (should-error (eval (cons 'if if-tail))))
+    (should-error (eval (cons 'if if-tail) nil) :type 'void-variable)
+    (should-error (eval (cons 'if if-tail) t) :type 'void-variable))
   (let ((if-tail (list '(progn (setcdr if-tail "abc") nil) t)))
-    (should-error (eval (cons 'if if-tail)))))
+    (should-error (eval (cons 'if if-tail) nil) :type 'void-variable)
+    (should-error (eval (cons 'if if-tail) t) :type 'void-variable)))
 
 (ert-deftest eval-tests--let-with-circular-defs ()
   "Check that Emacs reports an error for (let VARS ...) when VARS is circular."
   (let ((vars (list 'v)))
     (setcdr vars vars)
     (dolist (let-sym '(let let*))
-      (should-error (eval (list let-sym vars))))))
+      (should-error (eval (list let-sym vars) nil)))))
 
 (ert-deftest eval-tests--mutating-cond ()
   "Check that Emacs doesn't crash on a cond clause that mutates during eval."
   (let ((clauses (list '((progn (setcdr clauses "ouch") nil)))))
-    (should-error (eval (cons 'cond clauses)))))
+    (should-error (eval (cons 'cond clauses) nil))
+    (should-error (eval (cons 'cond clauses) t))))
 
 (defun eval-tests--exceed-specbind-limit ()
   (defvar eval-tests--var1)
@@ -184,7 +188,8 @@ are found on the stack and therefore not garbage collected."
 Don't handle destructive splicing in backquote expressions (like
 in Common Lisp).  Instead, make sure substitution in backquote
 expressions works for identifiers starting with period."
-  (should (equal (let ((.x 'identity)) (eval `(,.x 'ok))) 'ok)))
+  (should (equal (let ((.x 'identity)) (eval `(,.x 'ok) nil)) 'ok))
+  (should (equal (let ((.x 'identity)) (eval `(,.x 'ok) t)) 'ok)))
 
 (ert-deftest eval-tests/backtrace-in-batch-mode ()
   (let ((emacs (expand-file-name invocation-name invocation-directory)))