;;; lisp-tests.el --- Test Lisp editing commands     -*- lexical-binding: t; -*-

;; Copyright (C) 2013-2023 Free Software Foundation, Inc.

;; Author: Aaron S. Hawley <aaron.s.hawley@gmail.com>
;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
;; Author: Daniel Colascione <dancol@dancol.org>
;; Author: Marcin Borkowski <mbork@mbork.pl>
;; Keywords: internal

;; 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:

;; Testing of `forward-sexp' and related functions.

;;; Code:

(require 'ert)
(require 'python)
(require 'cl-lib)

(ert-deftest lisp-forward-sexp-1-empty-parens ()
  "Test basics of \\[forward-sexp]."
  (with-temp-buffer
    (insert "()")
    (goto-char (point-min))
    (should (null
      (forward-sexp 1)))))

(ert-deftest lisp-forward-sexp-1-error-mismatch ()
  "Test basics of \\[forward-sexp]."
  (with-temp-buffer
    (insert "(")
    (goto-char (point-min))
    (should-error
      (forward-sexp 1))))

(ert-deftest lisp-backward-sexp-1-empty-parens ()
  "Test basics of \\[backward-sexp]."
  (with-temp-buffer
    (insert "()")
    (should (null
      (forward-sexp -1)))))

(ert-deftest lisp-backward-sexp-1-error-mismatch ()
  "Test mismatched parens with \\[backward-sexp]."
  (with-temp-buffer
    (insert "(")
    (should-error
      (forward-sexp -1))))

(ert-deftest lisp-forward-sexp-1-eobp ()
  "Test \\[forward-sexp] at `eobp'."
  (with-temp-buffer
    (insert "()")
    (should (null ;; (should-error ;; No, per #13994
      (forward-sexp 1)))))

(ert-deftest lisp-backward-sexp-1-eobp ()
  "Test \\[backward-sexp] at `bobp'."
  (with-temp-buffer
    (insert "()")
    (goto-char (point-min))
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp -1)))))

(ert-deftest lisp-forward-sexp-2-eobp ()
  "Test \\[forward-sexp] beyond `eobp'."
  (with-temp-buffer
    (insert "()")
    (goto-char (point-min))
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp 2)))
    (should (eobp))))

(ert-deftest lisp-backward-sexp-2-bobp ()
  "Test \\[backward-sexp] beyond `bobp'."
  (with-temp-buffer
    (insert "()")
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp -2)))
    (should (bobp))))

(ert-deftest lisp-forward-sexp-2-eobp-and-subsequent ()
  "Test \\[forward-sexp] beyond `eobp' and again."
  (with-temp-buffer
    (insert "()")
    (goto-char (point-min))
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp 2)))
    (should (eobp))
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp 1)))))

(ert-deftest lisp-backward-sexp-2-bobp-and-subsequent ()
  "Test \\[backward-sexp] ahead of `bobp' and again."
  (with-temp-buffer
    (insert "()")
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp -2)))
    (should (bobp))
    (should (null ;; (should-error ;; No, per #13994
     (forward-sexp -1)))))

(ert-deftest mark-sexp-forward-one-forward-check-point ()
  (should (equal 14
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (end-of-line)
                                      (mark-sexp-forward)
                                      (point)))))

(ert-deftest mark-sexp-forward-one-forward-pass-value-check-point ()
  (should (equal 14
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (end-of-line)
                                      (mark-sexp-forward 1)
                                      (point)))))

(ert-deftest mark-sexp-forward-one-forward-check-region ()
  (should (equal "(6)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line 2)
                                   (mark-sexp-forward)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-forward-one-forward-pass-value-check-region ()
  (should (equal "(6)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line 2)
                                   (mark-sexp-forward 1)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-backward-one-backward-check-point ()
  (should (equal 14
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-backward)
                                   (point)))))

(ert-deftest mark-sexp-backward-one-backward-check-region ()
  (should (equal "(3 4 5)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-backward)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-one-forward-then-one-backward-check-point ()
  (should (equal 7
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward)
                                   (mark-sexp-backward)
                                   (point)))))

(ert-deftest mark-sexp-one-forward-then-one-backward-check-region ()
  (should (equal "(3 4 5)
(6)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward)
                                   (mark-sexp-backward)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-one-forward-then-one-backward-then-one-forward-check-point ()
  (should (equal 7
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward)
                                   (mark-sexp-backward)
                                   (mark-sexp-forward)
                                   (point)))))

(ert-deftest mark-sexp-one-forward-then-one-backward-then-one-forward-check-region ()
  (should (equal 7
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward)
                                   (mark-sexp-backward)
                                   (mark-sexp-forward)
                                   (point)))))



(ert-deftest mark-sexp-forward-one-forward-one-back-one-forward-check-region ()
  (should (equal "(3 4 5)
(6)
(7 8)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward)
                                   (mark-sexp-backward)
                                   (mark-sexp-forward)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-forward-two-forward-check-point ()
  (should (equal 14
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward 2)
                                   (point)))))

(ert-deftest mark-sexp-forward-two-forward-check-region ()
  (should (equal "
(6)
(7 8)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-forward 2)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest mark-sexp-backward-two-backward-check-point ()
  (should (equal 14
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-backward 2)
                                   (point)))))

(ert-deftest mark-sexp-backward-two-backward-check-region ()
  (should (equal "(1 2)
(3 4 5)"
                 (with-temp-buffer (insert "(1 2)
(3 4 5)
(6)
(7 8)")
                                   (goto-char (point-min))
                                   (forward-line)
                                   (end-of-line)
                                   (mark-sexp-backward 2)
                                   (buffer-substring-no-properties (region-beginning)
                                                                   (region-end))))))

(ert-deftest lisp-delete-pair-parens ()
  "Test \\[delete-pair] with parens."
  (with-temp-buffer
    (insert "(foo)")
    (goto-char (point-min))
    (delete-pair)
    (should (string-equal "foo" (buffer-string)))))

(ert-deftest lisp-delete-pair-quotation-marks ()
  "Test \\[delete-pair] with quotation marks."
  (with-temp-buffer
    (insert "\"foo\"")
    (goto-char (point-min))
    (delete-pair)
    (should (string-equal "foo" (buffer-string)))))

(ert-deftest lisp-delete-pair-quotes-in-text-mode ()
  "Test \\[delete-pair] against string in Text Mode for #15014."
  (with-temp-buffer
    (text-mode)
    (insert "\"foo\"")
    (goto-char (point-min))
    (should-error (delete-pair))))

(ert-deftest lisp-delete-pair-quotes-text-mode-syntax-table ()
  "Test \\[delete-pair] with modified Text Mode syntax for #15014."
  (with-temp-buffer
    (text-mode)
    (let ((st (copy-syntax-table text-mode-syntax-table)))
      (with-syntax-table st
        ;; (modify-syntax-entry ?\" "." text-mode-syntax-table)
        (modify-syntax-entry ?\" "$" st)
        (insert "\"foo\"")
        (goto-char (point-min))
        (delete-pair)
        (should (string-equal "foo" (buffer-string)))))))

(ert-deftest lisp-forward-sexp-elisp-inside-symbol ()
  "Test \\[forward-sexp] on symbol in Emacs Lisp Mode for #20492."
  (with-temp-buffer
    (emacs-lisp-mode)
    (insert "hide-ifdef-env ")
    (insert (concat (number-sequence 32 126)))
    (goto-char (point-min))
    (re-search-forward "hide" nil t) ;; (forward-char 4)
    (should (looking-at "-"))
    (forward-sexp)
    (should (looking-at " "))))

(ert-deftest lisp-forward-sexp-elisp-quoted-symbol ()
  "Test \\[forward-sexp] on symbol in Emacs Lisp Mode for #20492."
  (with-temp-buffer
    (emacs-lisp-mode)
    (insert "`hide-ifdef-env'.")
    (goto-char (point-min))
    (re-search-forward "hide" nil t) ;; (forward-char 5)
    (should (= ?- (char-after)))
    (forward-sexp)
    (should (= ?. (char-before)))))

(ert-deftest lisp-forward-sexp-python-triple-quoted-string ()
  "Test \\[forward-sexp] on Python doc strings for #11321."
  (with-temp-buffer
    (insert "\"\"\"Triple-quoted string\"\"\"")
    (goto-char (point-min))
    (let ((python-indent-guess-indent-offset nil))
      (python-mode))
    (forward-sexp)
    (should (eobp))))

(ert-deftest lisp-forward-sexp-python-triple-quotes-string ()
  "Test \\[forward-sexp] on Python doc strings for #11321."
  (with-temp-buffer
    (insert "'''Triple-quoted string'''")
    (goto-char (point-min))
    (let ((python-indent-guess-indent-offset nil))
      (python-mode))
    (forward-sexp)
    (should (eobp))))

(ert-deftest lisp-forward-sexp-emacs-lisp-semi-char-error ()
  "Test \\[forward-sexp] on expression with unquoted semicolon per #4030."
  (with-temp-buffer
    (emacs-lisp-mode)
    (insert "(insert ?;)")
    (goto-char (point-min))
    (should-error (forward-sexp)))) ;; FIXME: Shouldn't be an error.

(ert-deftest lisp-forward-sexp-emacs-lisp-quote-char ()
  "Test \\[forward-sexp] on expression with unquoted quote per #4030."
  (with-temp-buffer
    (emacs-lisp-mode)
    (insert "(insert ?\")")
    (goto-char (point-min))
    (should-error (forward-sexp)))) ;; FIXME: Shouldn't be an error.

;; Test some core Elisp rules.
(defvar c-e-x)
(ert-deftest core-elisp-tests-1-defvar-in-let ()
  "Test some core Elisp rules."
  (with-temp-buffer
    ;; Check that when defvar is run within a let-binding, the toplevel default
    ;; is properly initialized.
    (should (equal (list (let ((c-e-x 1)) (defvar c-e-x 2) c-e-x) c-e-x)
                   '(1 2)))
    (should (equal (list (let ((c-e-x 1))
                           (defcustom c-e-x 2 "doc" :group 'blah :type 'integer) c-e-x)
                         c-e-x)
                   '(1 2)))))

(ert-deftest core-elisp-tests-2-window-configurations ()
  "Test properties of window-configurations."
  (let ((wc (current-window-configuration)))
    (with-current-buffer (window-buffer (frame-selected-window))
      (push-mark)
      (activate-mark))
    (set-window-configuration wc)
    (should (or (not mark-active) (mark)))))

(ert-deftest core-elisp-tests-3-backquote ()
  (should (eq 3 (eval ``,,'(+ 1 2) t))))

;; Test up-list and backward-up-list.
(defun lisp-run-up-list-test (fn data start instructions)
  (cl-labels ((posof (thing)
                (and (symbolp thing)
                     (= (length (symbol-name thing)) 1)
                     (- (aref (symbol-name thing) 0) ?a -1))))
    (with-temp-buffer
      (set-syntax-table (make-syntax-table))
      ;; Use a syntax table in which single quote is a string
      ;; character so that we can embed the test data in a lisp string
      ;; literal.
      (modify-syntax-entry ?\' "\"")
      (insert data)
      (goto-char (posof start))
      (dolist (instruction instructions)
        (cond ((posof instruction)
               (funcall fn)
               (should (eql (point) (posof instruction))))
              ((symbolp instruction)
               (should-error (funcall fn)
                             :type instruction))
              (t (cl-assert nil nil "unknown ins")))))))

(defmacro define-lisp-up-list-test (name fn data start &rest expected)
  `(ert-deftest ,name ()
     (lisp-run-up-list-test ,fn ,data ',start ',expected)))

(define-lisp-up-list-test up-list-basic
  (lambda () (up-list))
  (or "(1 1 (1 1) 1 (1 1) 1)")
  ;;   abcdefghijklmnopqrstuv
  i k v scan-error)

(define-lisp-up-list-test up-list-with-forward-sexp-function
  (lambda ()
    (let ((forward-sexp-function
           (lambda (&optional arg)
             (let ((forward-sexp-function nil))
               (forward-sexp arg)))))
      (up-list)))
  (or "(1 1 (1 1) 1 (1 1) 1)")
  ;;   abcdefghijklmnopqrstuv
  i k v scan-error)

(define-lisp-up-list-test up-list-out-of-string
  (lambda () (up-list 1 t))
  (or "1 (1 '2 2 (2 2 2' 1) 1")
  ;;   abcdefghijklmnopqrstuvwxy
  o r u scan-error)

(define-lisp-up-list-test up-list-cross-string
  (lambda () (up-list 1 t))
  (or "(1 '2 ( 2' 1 '2 ) 2' 1)")
  ;;   abcdefghijklmnopqrstuvwxy
  i r u x scan-error)

(define-lisp-up-list-test up-list-no-cross-string
  (lambda () (up-list 1 t t))
  (or "(1 '2 ( 2' 1 '2 ) 2' 1)")
  ;;   abcdefghijklmnopqrstuvwxy
  i k x user-error)

(define-lisp-up-list-test backward-up-list-basic
  (lambda () (backward-up-list))
  (or "(1 1 (1 1) 1 (1 1) 1)")
  ;;   abcdefghijklmnopqrstuv
  i f a scan-error)

;;; Helpers

(eval-and-compile
  (defvar elisp-test-point-position-regex "=!\\([a-zA-Z0-9-]+\\)="
    "A regexp matching placeholders for point position for
`elisp-tests-with-temp-buffer'."))

;; Copied and heavily modified from `python-tests-with-temp-buffer'
(defmacro elisp-tests-with-temp-buffer (contents &rest body)
  "Create an `emacs-lisp-mode' enabled temp buffer with CONTENTS.
BODY is the code to be executed within the temp buffer.  Point is
always located at the beginning of buffer.  CONTENTS is an
expression that must evaluate to a string at compile time.  Words
of the form =!NAME= in CONTENTS are removed, and a for each one a
variable called NAME is bound to the position of the word's
start."
  (declare (indent 1) (debug (def-form body)))
  (let* ((var-pos nil)
         (text (with-temp-buffer
                 (insert (eval contents t))
                 (goto-char (point-min))
                 (while (re-search-forward elisp-test-point-position-regex nil t)
                   (push (list (intern (match-string-no-properties 1))
                               (match-beginning 0))
                         var-pos)
                   (delete-region (match-beginning 0)
                                  (match-end 0)))
                 (buffer-string))))
    `(with-temp-buffer
       (emacs-lisp-mode)
       (insert ,text)
       (goto-char (point-min))
       (let ,var-pos
         ;; Let the =!POSITION= variables be ignorable.
         ,@(mapcar (lambda (v-p) `(ignore ,(car v-p))) var-pos)
         ,@body))))

;;; mark-defun

(eval-and-compile
  (defvar mark-defun-test-buffer
    ";; Comment header
=!before-1=
\(defun func-1 (arg)
  =!inside-1=\"docstring\"
  body)
=!after-1==!before-2=
;; Comment before a defun
\(d=!inside-2=efun func-2 (arg)
  \"docstring\"
  body)
=!after-2==!before-3=
\(defun func-3 (arg)
  \"docstring\"=!inside-3=
  body)
=!after-3==!before-4=(defun func-4 (arg)
  \"docstring\"=!inside-4=
  body)
=!after-4=
;; end
"
    "Test buffer for `mark-defun'."))

(ert-deftest mark-defun-forward-one-forward-check-point ()
  (should (equal 18
                 (with-temp-buffer (insert "(defun foo () 2)

(defun bar () 3)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (mark-defun-forward)
                                      (point)))))

(ert-deftest mark-defun-forward-one-forward-check-region ()
  (should (equal "
(defun bar () 3)"
                 (with-temp-buffer (insert "(defun foo () 2)

(defun bar () 3)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (mark-defun-forward)
                                      (buffer-substring-no-properties (region-beginning)
                                                                      (region-end))))))

(ert-deftest mark-defun-backward-one-backward-check-point ()
  (should (equal 18
                 (with-temp-buffer (insert "(defun foo () 2)

(defun bar () 3)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (mark-defun-backward)
                                      (point)))))

(ert-deftest mark-defun-backward-one-backward-check-region ()
  (should (equal "(defun foo () 2)
"
                 (with-temp-buffer (insert "(defun foo () 2)

(defun bar () 2)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (mark-defun-backward)
                                      (buffer-substring-no-properties (region-beginning)
                                                                      (region-end))))))


(ert-deftest mark-defun-backward-two-backward-check-region ()
  (should (equal "(defun foo () 2)
(defun bar () 3)"
                 (with-temp-buffer (insert "(defun foo () 2)
(defun bar () 3)
(defun baz () 5)
(defun biff () 7)")
                                      (goto-char (point-min))
                                      (forward-line)
                                      (end-of-line)
                                      (mark-defun-backward)
                                      (mark-defun-backward)
                                      (buffer-substring-no-properties (region-beginning)
                                                                      (region-end))))))


;;; end-of-defun

(ert-deftest end-of-defun-twice ()
  "Test behavior of prefix arg for `end-of-defun' (Bug#24427).
Calling `end-of-defun' twice should be the same as a prefix arg
of two."
  (setq last-command nil)
  (cl-flet ((eod2 (lambda ()
                    (goto-char (point-min))
                    (end-of-defun)
                    (end-of-defun)
                    (let ((pt-eod2 (point)))
                      (goto-char (point-min))
                      (end-of-defun 2)
                      (should (= (point) pt-eod2))))))
    (with-temp-buffer
      (insert "\
\(defun a ())

\(defun b ())

\(defun c ())")
      (eod2))
    (with-temp-buffer
      (insert "\
\(defun a ())
\(defun b ())
\(defun c ())")
      (eod2)))
  (elisp-tests-with-temp-buffer ";; Comment header

\(defun func-1 (arg)
  \"docstring\"
  body)
=!p1=
;; Comment before a defun
\(defun func-2 (arg)
  \"docstring\"
  body)

\(defun func-3 (arg)
  \"docstring\"
  body)
=!p2=(defun func-4 (arg)
  \"docstring\"
  body)

;; end
"
    (goto-char p1)
    (end-of-defun 2)
    (should (= (point) p2))))

;;; mark-defun

(ert-deftest mark-defun-no-arg-region-inactive ()
  "Test `mark-defun' with no prefix argument and inactive
region."
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      mark-defun-test-buffer
    ;; mark-defun inside a defun, with comments and an empty line
    ;; before
    (goto-char inside-1)
    (mark-defun)
    (should (= (point) before-1))
    (should (= (mark) after-1))
    ;; mark-defun inside a defun with comments before
    (deactivate-mark)
    (goto-char inside-2)
    (mark-defun)
    (should (= (point) before-2))
    (should (= (mark) after-2))
    ;; mark-defun inside a defun with empty line before
    (deactivate-mark)
    (goto-char inside-3)
    (mark-defun)
    (should (= (point) before-3))
    (should (= (mark) after-3))
    ;; mark-defun inside a defun with another one right before
    (deactivate-mark)
    (goto-char inside-4)
    (mark-defun)
    (should (= (point) before-4))
    (should (= (mark) after-4))
    ;; mark-defun between a comment and a defun
    (deactivate-mark)
    (goto-char before-1)
    (mark-defun)
    (should (= (point) before-1))
    (should (= (mark) after-1))
    ;; mark-defun between defuns
    (deactivate-mark)
    (goto-char before-3)
    (mark-defun)
    (should (= (point) before-3))
    (should (= (mark) after-3))
    ;; mark-defun in comment right before the defun
    (deactivate-mark)
    (goto-char before-2)
    (mark-defun)
    (should (= (point) before-2))
    (should (= (mark) after-2))))

(ert-deftest mark-defun-no-arg-region-active ()
  "Test `mark-defun' with no prefix argument and active
region."
  (transient-mark-mode 1)
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      mark-defun-test-buffer
    ;; mark-defun when a defun is marked
    (goto-char before-1)
    (set-mark after-1)
    (mark-defun)
    (should (= (point) before-1))
    (should (= (mark) after-2))
    ;; mark-defun when two defuns are marked
    (deactivate-mark)
    (goto-char before-1)
    (set-mark after-2)
    (mark-defun)
    (should (= (point) before-1))
    (should (= (mark) after-3))))

(ert-deftest mark-defun-arg-region-active ()
  "Test `mark-defun' with a prefix arg and active region."
  (transient-mark-mode 1)
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      mark-defun-test-buffer
    ;; mark-defun with positive arg when a defun is marked
    (goto-char before-1)
    (set-mark after-1)
    (mark-defun 2)
    (should (= (point) before-1))
    (should (= (mark) after-3))
    ;; mark-defun with arg=-1 when a defun is marked
    (goto-char before-2)
    (set-mark after-2)
    (mark-defun -1)
    (should (= (point) before-1))
    (should (= (mark) after-2))
    ;; mark-defun with arg=-2 when a defun is marked
    (goto-char before-3)
    (set-mark after-3)
    (mark-defun -2)
    (should (= (point) before-1))
    (should (= (mark) after-3))))

(ert-deftest mark-defun-pos-arg-region-inactive ()
  "Test `mark-defun' with positive argument and inactive
  region."
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      mark-defun-test-buffer
    ;; mark-defun with positive arg inside a defun
    (goto-char inside-1)
    (mark-defun 2)
    (should (= (point) before-1))
    (should (= (mark) after-2))
    ;; mark-defun with positive arg between defuns
    (deactivate-mark)
    (goto-char before-3)
    (mark-defun 2)
    (should (= (point) before-3))
    (should (= (mark) after-4))
    ;; mark-defun with positive arg in a comment
    (deactivate-mark)
    (goto-char before-2)
    (mark-defun 2)
    (should (= (point) before-2))
    (should (= (mark) after-3))))

(ert-deftest mark-defun-neg-arg-region-inactive ()
  "Test `mark-defun' with negative argument and inactive
  region."
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      mark-defun-test-buffer
    ;; mark-defun with arg=-1 inside a defun
    (goto-char inside-1)
    (mark-defun -1)
    (should (= (point) before-1))
    (should (= (mark) after-1))
    ;; mark-defun with arg=-1 between defuns
    (deactivate-mark)
    (goto-char after-2)
    (mark-defun -1)
    (should (= (point) before-2))
    (should (= (mark) after-2))
    ;; mark-defun with arg=-1 in a comment
    ;; (this is probably not an optimal behavior...)
    (deactivate-mark)
    (goto-char before-2)
    (mark-defun -1)
    (should (= (point) before-1))
    (should (= (mark) after-1))
    ;; mark-defun with arg=-2 inside a defun
    (deactivate-mark)
    (goto-char inside-4)
    (mark-defun -2)
    (should (= (point) before-3))
    (should (= (mark) after-4))
    ;; mark-defun with arg=-2 between defuns
    (deactivate-mark)
    (goto-char before-3)
    (mark-defun -2)
    (should (= (point) before-1))
    (should (= (mark) after-2)))
  (elisp-tests-with-temp-buffer         ; test case submitted by Drew Adams
      "(defun a ()
  nil)
=!before-b=(defun b ()
=!in-b=  nil)
=!after-b=;;;;
\(defun c ()
  nil)
"
    (setq last-command nil)
    (goto-char in-b)
    (mark-defun -1)
    (should (= (point) before-b))
    (should (= (mark) after-b))))

(ert-deftest mark-defun-bob ()
  "Test `mark-defun' at the beginning of buffer."
  ;; Bob, comment, newline, defun
  (setq last-command nil)
  (elisp-tests-with-temp-buffer
      ";; Comment at the bob
=!before=
\(defun func (arg)=!inside=
  \"docstring\"
  body)
=!after="
    (goto-char inside)
    (mark-defun)
    (should (= (point) before))
    (should (= (mark) after)))
  ;; Bob, newline, comment, defun
  (elisp-tests-with-temp-buffer
      "=!before=
;; Comment before the defun
\(defun func (arg)=!inside=
  \"docstring\"
  body)
=!after="
    (goto-char inside)
    (mark-defun)
    (should (= (point) before))
    (should (= (mark) after)))
  ;; Bob, comment, defun
  (elisp-tests-with-temp-buffer
      "=!before=;; Comment at the bob before the defun
\(defun func (arg)=!inside=
  \"docstring\"
  body)
=!after="
    (goto-char inside)
    (mark-defun)
    (should (= (point) before))
    (should (= (mark) after)))
  ;; Bob, newline, comment, newline, defun
  (elisp-tests-with-temp-buffer
      "
;; Comment before the defun
=!before=
\(defun func (arg)=!inside=
  \"docstring\"
  body)
=!after="
    (goto-char inside)
    (mark-defun)
    (should (= (point) before))
    (should (= (mark) after))))

(ert-deftest lisp-fill-paragraph-colon ()
  "Keywords below Emacs Lisp docstrings should not be filled (Bug#24622).
Keywords inside docstrings should be filled (Bug#7751)."
  (elisp-tests-with-temp-buffer
      "
\(defcustom custom value
  \"First\n
Second\n
=!inside=Third line\"
  =!keywords=:type 'sexp
  :version \"26.1\"
  :group 'lisp-tests)"
    (goto-char inside)
    (fill-paragraph)
    (goto-char keywords)
    (beginning-of-line)
    (should (looking-at "  :type 'sexp\n  :version \"26.1\"\n  :")))
  (elisp-tests-with-temp-buffer
      "
\(defun foo ()
  \"Summary.
=!inside=Testing keywords: :one :two :three\"
  (body))" ; FIXME: Remove parens around body to test Bug#28937 once it's fixed
    (goto-char inside)
    (let ((emacs-lisp-docstring-fill-column 30))
      (fill-paragraph))
    (forward-line)
    (should (looking-at ":three"))
    (end-of-line)
    (should-not (eq (preceding-char) ?\)))))

(provide 'lisp-tests)
;;; lisp-tests.el ends here