code.delx.au - gnu-emacs/blob - test/automated/simple-test.el

   1 ;;; simple-test.el --- Tests for simple.el           -*- lexical-binding: t; -*-
   2
   3 ;; Copyright (C) 2015  Free Software Foundation, Inc.
   4
   5 ;; Author: Artur Malabarba <bruce.connor.am@gmail.com>
   6
   7 ;; This program is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation, either version 3 of the License, or
  10 ;; (at your option) any later version.
  11
  12 ;; This program is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 ;;; Code:
  21
  22 (require 'ert)
  23
  24 (defmacro simple-test--dummy-buffer (&rest body)
  25   (declare (indent 0)
  26            (debug t))
  27   `(with-temp-buffer
  28      (emacs-lisp-mode)
  29      (setq indent-tabs-mode nil)
  30      (insert "(a b")
  31      (save-excursion (insert " c d)"))
  32      ,@body
  33      (cons (buffer-substring (point-min) (point))
  34            (buffer-substring (point) (point-max)))))
  35
  36
  37 \f
  38 ;;; `newline'
  39 (ert-deftest newline ()
  40   (should-error (newline -1))
  41   (should (equal (simple-test--dummy-buffer (newline 1))
  42                  '("(a b\n" . " c d)")))
  43   (should (equal (simple-test--dummy-buffer
  44                    (electric-indent-mode -1)
  45                    (call-interactively #'newline))
  46                  '("(a b\n" . " c d)")))
  47   (should (equal (simple-test--dummy-buffer
  48                    (let ((current-prefix-arg 5))
  49                      (call-interactively #'newline)))
  50                  '("(a b\n\n\n\n\n" . " c d)")))
  51   (should (equal (simple-test--dummy-buffer (newline 5))
  52                  '("(a b\n\n\n\n\n" . " c d)")))
  53   (should (equal (simple-test--dummy-buffer
  54                    (forward-char 1)
  55                    (newline 1))
  56                  '("(a b \n" . "c d)"))))
  57
  58 (ert-deftest newline-indent ()
  59   (should (equal (simple-test--dummy-buffer
  60                    (electric-indent-local-mode 1)
  61                    (newline 1))
  62                  '("(a b\n" . " c d)")))
  63   (should (equal (simple-test--dummy-buffer
  64                    (electric-indent-local-mode 1)
  65                    (newline 1 'interactive))
  66                  '("(a b\n   " . "c d)")))
  67   (should (equal (simple-test--dummy-buffer
  68                    (electric-indent-local-mode 1)
  69                    (let ((current-prefix-arg nil))
  70                      (call-interactively #'newline)
  71                      (call-interactively #'newline)))
  72                  '("(a b\n\n   " . "c d)")))
  73   (should (equal (simple-test--dummy-buffer
  74                    (electric-indent-local-mode 1)
  75                    (newline 5 'interactive))
  76                  '("(a b\n\n\n\n\n   " . "c d)")))
  77   (should (equal (simple-test--dummy-buffer
  78                    (electric-indent-local-mode 1)
  79                    (let ((current-prefix-arg 5))
  80                      (call-interactively #'newline)))
  81                  '("(a b\n\n\n\n\n   " . "c d)")))
  82   (should (equal (simple-test--dummy-buffer
  83                    (forward-char 1)
  84                    (electric-indent-local-mode 1)
  85                    (newline 1 'interactive))
  86                  '("(a b\n   " . "c d)"))))
  87
  88 \f
  89 ;;; `open-line'
  90 (ert-deftest open-line ()
  91   (should-error (open-line -1))
  92   (should-error (open-line))
  93   (should (equal (simple-test--dummy-buffer (open-line 1))
  94                  '("(a b" . "\n c d)")))
  95   (should (equal (simple-test--dummy-buffer
  96                    (electric-indent-mode -1)
  97                    (call-interactively #'open-line))
  98                  '("(a b" . "\n c d)")))
  99   (should (equal (simple-test--dummy-buffer
 100                    (let ((current-prefix-arg 5))
 101                      (call-interactively #'open-line)))
 102                  '("(a b" . "\n\n\n\n\n c d)")))
 103   (should (equal (simple-test--dummy-buffer (open-line 5))
 104                  '("(a b" . "\n\n\n\n\n c d)")))
 105   (should (equal (simple-test--dummy-buffer
 106                    (forward-char 1)
 107                    (open-line 1))
 108                  '("(a b " . "\nc d)"))))
 109
 110 (ert-deftest open-line-margin-and-prefix ()
 111   (should (equal (simple-test--dummy-buffer
 112                    (let ((left-margin 10))
 113                      (open-line 3)))
 114                  '("(a b" . "\n\n\n          c d)")))
 115   (should (equal (simple-test--dummy-buffer
 116                    (forward-line 0)
 117                    (let ((left-margin 2))
 118                      (open-line 1)))
 119                  '("  " . "\n  (a b c d)")))
 120   (should (equal (simple-test--dummy-buffer
 121                    (let ((fill-prefix "- - "))
 122                      (open-line 1)))
 123                  '("(a b" . "\n c d)")))
 124   (should (equal (simple-test--dummy-buffer
 125                    (forward-line 0)
 126                    (let ((fill-prefix "- - "))
 127                      (open-line 1)))
 128                  '("- - " . "\n(a b c d)"))))
 129
 130 (ert-deftest open-line-indent ()
 131   (should (equal (simple-test--dummy-buffer
 132                    (electric-indent-local-mode 1)
 133                    (open-line 1))
 134                  '("(a b" . "\n c d)")))
 135   (should (equal (simple-test--dummy-buffer
 136                    (electric-indent-local-mode 1)
 137                    (open-line 1 'interactive))
 138                  '("(a b" . "\n   c d)")))
 139   (should (equal (simple-test--dummy-buffer
 140                    (electric-indent-local-mode 1)
 141                    (let ((current-prefix-arg nil))
 142                      (call-interactively #'open-line)
 143                      (call-interactively #'open-line)))
 144                  '("(a b" . "\n\n   c d)")))
 145   (should (equal (simple-test--dummy-buffer
 146                    (electric-indent-local-mode 1)
 147                    (open-line 5 'interactive))
 148                  '("(a b" . "\n\n\n\n\n   c d)")))
 149   (should (equal (simple-test--dummy-buffer
 150                    (electric-indent-local-mode 1)
 151                    (let ((current-prefix-arg 5))
 152                      (call-interactively #'open-line)))
 153                  '("(a b" . "\n\n\n\n\n   c d)")))
 154   (should (equal (simple-test--dummy-buffer
 155                    (forward-char 1)
 156                    (electric-indent-local-mode 1)
 157                    (open-line 1 'interactive))
 158                  '("(a b" . "\n   c d)"))))
 159
 160 (ert-deftest open-line-hook ()
 161   (let* ((x 0)
 162          (inc (lambda () (setq x (1+ x)))))
 163     (simple-test--dummy-buffer
 164       (add-hook 'post-self-insert-hook inc nil 'local)
 165       (open-line 1))
 166     (should (= x 0))
 167     (simple-test--dummy-buffer
 168       (add-hook 'post-self-insert-hook inc nil 'local)
 169       (open-line 1 'interactive))
 170     (should (= x 1))
 171
 172     (unwind-protect
 173         (progn
 174           (add-hook 'post-self-insert-hook inc)
 175           (simple-test--dummy-buffer
 176             (open-line 1))
 177           (should (= x 1))
 178           (simple-test--dummy-buffer
 179             (open-line 10 'interactive))
 180           (should (= x 2)))
 181       (remove-hook 'post-self-insert-hook inc))))
 182
 183 \f
 184 ;;; `delete-trailing-whitespace'
 185 (ert-deftest simple-delete-trailing-whitespace ()
 186   "Test bug#21766: delete-whitespace sometimes deletes non-whitespace."
 187   (defvar python-indent-guess-indent-offset)  ; to avoid a warning
 188   (let ((python (featurep 'python))
 189         (python-indent-guess-indent-offset nil)
 190         (delete-trailing-lines t))
 191     (unwind-protect
 192         (with-temp-buffer
 193           (python-mode)
 194           (insert (concat "query = \"\"\"WITH filtered AS \n"
 195                           "WHERE      \n"
 196                           "\"\"\".format(fv_)\n"
 197                           "\n"
 198                           "\n"))
 199           (delete-trailing-whitespace)
 200           (should (equal (count-lines (point-min) (point-max)) 3)))
 201       ;; Let's clean up if running interactive
 202       (unless (or noninteractive python)
 203         (unload-feature 'python)))))
 204
 205
 206 ;;; auto-boundary tests
 207 (ert-deftest undo-auto--boundary-timer ()
 208   (should
 209    undo-auto--current-boundary-timer))
 210
 211 (ert-deftest undo-auto--boundaries-added ()
 212   ;; The change in the buffer should have caused addition
 213   ;; to undo-auto--undoably-changed-buffers.
 214   (should
 215    (with-temp-buffer
 216      (setq buffer-undo-list nil)
 217      (insert "hello")
 218      (member (current-buffer) undo-auto--undoably-changed-buffers)))
 219   ;; The head of buffer-undo-list should be the insertion event, and
 220   ;; therefore not nil
 221   (should
 222    (with-temp-buffer
 223      (setq buffer-undo-list nil)
 224      (insert "hello")
 225      (car buffer-undo-list)))
 226   ;; Now the head of the buffer-undo-list should be a boundary and so
 227   ;; nil. We have to call auto-boundary explicitly because we are out
 228   ;; of the command loop
 229   (should-not
 230    (with-temp-buffer
 231      (setq buffer-undo-list nil)
 232      (insert "hello")
 233      (car buffer-undo-list)
 234      (undo-auto--boundaries 'test))))
 235
 236
 237
 238 (provide 'simple-test)
 239 ;;; simple-test.el ends here