;;; eval-tests.el --- unit tests for src/eval.c      -*- lexical-binding: t; -*-

;; Copyright (C) 2016-2018 Free Software Foundation, Inc.

;; Author: Philipp Stephani <phst@google.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 <https://www.gnu.org/licenses/>.

;;; Commentary:

;; Unit tests for src/eval.c.

;;; Code:

(require 'ert)

(ert-deftest eval-tests--bug24673 ()
  "Check that Bug#24673 has been fixed."
  ;; This should not crash.
  (should-error (funcall '(closure)) :type 'invalid-function))

(defvar byte-compile-debug)

(ert-deftest eval-tests--bugs-24912-and-24913 ()
  "Check that Emacs doesn't accept weird argument lists.
Bug#24912 and Bug#24913."
  (dolist (args '((&rest &optional)
                  (&rest a &optional) (&rest &optional a)
                  (&optional &optional) (&optional &optional a)
                  (&optional a &optional b)
                  (&rest &rest) (&rest &rest a)
                  (&rest a &rest b)))
    (should-error (eval `(funcall (lambda ,args)) t) :type 'invalid-function)
    (should-error (byte-compile-check-lambda-list args))
    (let ((byte-compile-debug t))
      (ert-info ((format "bytecomp: args = %S" args))
       (should-error (eval `(byte-compile (lambda ,args)) t))))))

(ert-deftest eval-tests-accept-empty-optional-rest ()
  "Check that Emacs accepts empty &optional and &rest arglists.
Bug#24912."
  (dolist (args '((&optional) (&rest) (&optional &rest)
                  (&optional &rest a) (&optional a &rest)))
    (let ((fun `(lambda ,args 'ok)))
      (ert-info ("eval")
        (should (eq (funcall (eval fun t)) 'ok)))
      (ert-info ("byte comp check")
        (byte-compile-check-lambda-list args))
      (ert-info ("bytecomp")
        (let ((byte-compile-debug t))
          (should (eq (funcall (byte-compile fun)) 'ok)))))))


(dolist (form '(let let*))
  (dolist (arg '(1 "a" [a]))
    (eval
     `(ert-deftest ,(intern (format "eval-tests--%s--%s" form (type-of arg))) ()
        ,(format "Check that the first argument of `%s' cannot be a %s"
                 form (type-of arg))
        (should-error (,form ,arg) :type 'wrong-type-argument))
     t)))

(ert-deftest eval-tests--if-dot-string ()
  "Check that Emacs rejects (if . \"string\")."
  (should-error (eval '(if . "abc")) :type 'wrong-type-argument)
  (let ((if-tail (list '(setcdr if-tail "abc") t)))
    (should-error (eval (cons 'if if-tail))))
  (let ((if-tail (list '(progn (setcdr if-tail "abc") nil) t)))
    (should-error (eval (cons 'if if-tail)))))

(ert-deftest eval-tests--let-with-circular-defs ()
  "Check that Emacs reports an error for (let VARS ...) when VARS is circular."
  (let ((vars (list 'v)))
    (setcdr vars vars)
    (dolist (let-sym '(let let*))
      (should-error (eval (list let-sym vars))))))

(ert-deftest eval-tests--mutating-cond ()
  "Check that Emacs doesn't crash on a cond clause that mutates during eval."
  (let ((clauses (list '((progn (setcdr clauses "ouch") nil)))))
    (should-error (eval (cons 'cond clauses)))))

;;; eval-tests.el ends here