test/automated/electric-tests.el

   1 ;;; electric-tests.el --- tests for electric.el
   2
   3 ;; Copyright (C) 2013-2014 Free Software Foundation, Inc.
   4
   5 ;; Author: João Távora <joaotavora@gmail.com>
   6 ;; Keywords:
   7
   8 ;; This program is free software; you can redistribute it and/or modify
   9 ;; it under the terms of the GNU General Public License as published by
  10 ;; the Free Software Foundation, either version 3 of the License, or
  11 ;; (at your option) any later version.
  12
  13 ;; This program is distributed in the hope that it will be useful,
  14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;; GNU General Public License for more details.
  17
  18 ;; You should have received a copy of the GNU General Public License
  19 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 ;;; Commentary:
  22
  23 ;; Tests for Electric Pair mode.
  24 ;; TODO: Add tests for other Electric-* functionality
  25
  26 ;;; Code:
  27 (require 'ert)
  28 (require 'ert-x)
  29 (require 'electric)
  30 (require 'elec-pair)
  31 (require 'cl-lib)
  32
  33 (defun call-with-saved-electric-modes (fn)
  34   (let ((saved-electric (if electric-pair-mode 1 -1))
  35         (saved-layout (if electric-layout-mode 1 -1))
  36         (saved-indent (if electric-indent-mode 1 -1)))
  37     (electric-pair-mode -1)
  38     (electric-layout-mode -1)
  39     (electric-indent-mode -1)
  40     (unwind-protect
  41         (funcall fn)
  42       (electric-pair-mode saved-electric)
  43       (electric-indent-mode saved-indent)
  44       (electric-layout-mode saved-layout))))
  45
  46 (defmacro save-electric-modes (&rest body)
  47   (declare (indent defun) (debug t))
  48   `(call-with-saved-electric-modes #'(lambda () ,@body)))
  49
  50 (defun electric-pair-test-for (fixture where char expected-string
  51                                        expected-point mode bindings fixture-fn)
  52   (with-temp-buffer
  53     (funcall mode)
  54     (insert fixture)
  55     (save-electric-modes
  56       (let ((last-command-event char)
  57             (transient-mark-mode 'lambda))
  58         (goto-char where)
  59         (funcall fixture-fn)
  60         (cl-progv
  61             (mapcar #'car bindings)
  62             (mapcar #'cdr bindings)
  63           (self-insert-command 1))))
  64     (should (equal (buffer-substring-no-properties (point-min) (point-max))
  65                    expected-string))
  66     (should (equal (point)
  67                    expected-point))))
  68
  69 (eval-when-compile
  70   (defun electric-pair-define-test-form (name fixture
  71                                               char
  72                                               pos
  73                                               expected-string
  74                                               expected-point
  75                                               skip-pair-string
  76                                               prefix
  77                                               suffix
  78                                               extra-desc
  79                                               mode
  80                                               bindings
  81                                               fixture-fn)
  82     (let* ((expected-string-and-point
  83             (if skip-pair-string
  84                 (with-temp-buffer
  85                   (cl-progv
  86                       ;; FIXME: avoid `eval'
  87                       (mapcar #'car (eval bindings))
  88                       (mapcar #'cdr (eval bindings))
  89                     (funcall mode)
  90                     (insert fixture)
  91                     (goto-char (1+ pos))
  92                     (insert char)
  93                     (cond ((eq (aref skip-pair-string pos)
  94                                ?p)
  95                            (insert (cadr (electric-pair-syntax-info char)))
  96                            (backward-char 1))
  97                           ((eq (aref skip-pair-string pos)
  98                                ?s)
  99                            (delete-char -1)
 100                            (forward-char 1)))
 101                     (list
 102                      (buffer-substring-no-properties (point-min) (point-max))
 103                      (point))))
 104               (list expected-string expected-point)))
 105            (expected-string (car expected-string-and-point))
 106            (expected-point (cadr expected-string-and-point))
 107            (fixture (format "%s%s%s" prefix fixture suffix))
 108            (expected-string (format "%s%s%s" prefix expected-string suffix))
 109            (expected-point (+ (length prefix) expected-point))
 110            (pos (+ (length prefix) pos)))
 111       `(ert-deftest ,(intern (format "electric-pair-%s-at-point-%s-in-%s%s"
 112                                      name
 113                                      (1+ pos)
 114                                      mode
 115                                      extra-desc))
 116            ()
 117          ,(format "With \"%s\", try input %c at point %d. \
 118 Should %s \"%s\" and point at %d"
 119                   fixture
 120                   char
 121                   (1+ pos)
 122                   (if (string= fixture expected-string)
 123                       "stay"
 124                     "become")
 125                   (replace-regexp-in-string "\n" "\\\\n" expected-string)
 126                   expected-point)
 127          (electric-pair-test-for ,fixture
 128                                  ,(1+ pos)
 129                                  ,char
 130                                  ,expected-string
 131                                  ,expected-point
 132                                  ',mode
 133                                  ,bindings
 134                                  ,fixture-fn)))))
 135
 136 (cl-defmacro define-electric-pair-test
 137     (name fixture
 138           input
 139           &key
 140           skip-pair-string
 141           expected-string
 142           expected-point
 143           bindings
 144           (modes '(quote (emacs-lisp-mode ruby-mode c++-mode)))
 145           (test-in-comments t)
 146           (test-in-strings t)
 147           (test-in-code t)
 148           (fixture-fn #'(lambda ()
 149                           (electric-pair-mode 1))))
 150   `(progn
 151      ,@(cl-loop
 152         for mode in (eval modes) ;FIXME: avoid `eval'
 153         append
 154         (cl-loop
 155          for (prefix suffix extra-desc) in
 156          (append (if test-in-comments
 157                      `((,(with-temp-buffer
 158                            (funcall mode)
 159                            (insert "z")
 160                            (comment-region (point-min) (point-max))
 161                            (buffer-substring-no-properties (point-min)
 162                                                            (1- (point-max))))
 163                         ""
 164                         "-in-comments")))
 165                  (if test-in-strings
 166                      `(("\"" "\"" "-in-strings")))
 167                  (if test-in-code
 168                      `(("" "" ""))))
 169          append
 170          (cl-loop
 171           for char across input
 172           for pos from 0
 173           unless (eq char ?-)
 174           collect (electric-pair-define-test-form
 175                    name
 176                    fixture
 177                    (aref input pos)
 178                    pos
 179                    expected-string
 180                    expected-point
 181                    skip-pair-string
 182                    prefix
 183                    suffix
 184                    extra-desc
 185                    mode
 186                    bindings
 187                    fixture-fn))))))
 188 \f
 189 ;;; Basic pairs and skips
 190 ;;;
 191 (define-electric-pair-test balanced-situation
 192   " (())  " "(((((((" :skip-pair-string "ppppppp"
 193   :modes '(ruby-mode))
 194
 195 (define-electric-pair-test too-many-openings
 196   " ((()) " "(((((((" :skip-pair-string "ppppppp")
 197
 198 (define-electric-pair-test too-many-closings
 199   " (())) " "(((((((" :skip-pair-string "------p")
 200
 201 (define-electric-pair-test too-many-closings-2
 202   "()   ) " "---(---" :skip-pair-string "-------")
 203
 204 (define-electric-pair-test too-many-closings-3
 205   ")()    " "(------" :skip-pair-string "-------")
 206
 207 (define-electric-pair-test balanced-autoskipping
 208   " (())  " "---))--" :skip-pair-string "---ss--")
 209
 210 (define-electric-pair-test too-many-openings-autoskipping
 211   " ((()) " "----))-" :skip-pair-string "-------")
 212
 213 (define-electric-pair-test too-many-closings-autoskipping
 214   " (())) " "---)))-" :skip-pair-string "---sss-")
 215
 216 \f
 217 ;;; Mixed parens
 218 ;;;
 219 (define-electric-pair-test mixed-paren-1
 220   "  ()]  " "-(-(---" :skip-pair-string "-p-p---")
 221
 222 (define-electric-pair-test mixed-paren-2
 223   "  [()  " "-(-()--" :skip-pair-string "-p-ps--")
 224
 225 (define-electric-pair-test mixed-paren-3
 226   "  (])  " "-(-()--" :skip-pair-string "---ps--")
 227
 228 (define-electric-pair-test mixed-paren-4
 229   "  ()]  " "---)]--" :skip-pair-string "---ss--")
 230
 231 (define-electric-pair-test mixed-paren-5
 232   "  [()  " "----(--" :skip-pair-string "----p--")
 233
 234 (define-electric-pair-test find-matching-different-paren-type
 235   "  ()]  " "-[-----" :skip-pair-string "-------")
 236
 237 (define-electric-pair-test find-matching-different-paren-type-inside-list
 238   "( ()]) " "-[-----" :skip-pair-string "-------")
 239
 240 (define-electric-pair-test ignore-different-nonmatching-paren-type
 241   "( ()]) " "-(-----" :skip-pair-string "-p-----")
 242
 243 (define-electric-pair-test autopair-keep-least-amount-of-mixed-unbalance
 244   "( ()]  " "-(-----" :skip-pair-string "-p-----")
 245
 246 (define-electric-pair-test dont-autopair-to-resolve-mixed-unbalance
 247   "( ()]  " "-[-----" :skip-pair-string "-------")
 248
 249 (define-electric-pair-test autopair-so-as-not-to-worsen-unbalance-situation
 250   "( (])  " "-[-----" :skip-pair-string "-p-----")
 251
 252 (define-electric-pair-test skip-over-partially-balanced
 253   " [([])   " "-----)---" :skip-pair-string "-----s---")
 254
 255 (define-electric-pair-test only-skip-over-at-least-partially-balanced-stuff
 256   " [([())  " "-----))--" :skip-pair-string "-----s---")
 257
 258
 259
 260 \f
 261 ;;; Quotes
 262 ;;;
 263 (define-electric-pair-test pair-some-quotes-skip-others
 264   " \"\"      " "-\"\"-----" :skip-pair-string "-ps------"
 265   :test-in-strings nil
 266   :bindings `((electric-pair-text-syntax-table
 267                . ,prog-mode-syntax-table)))
 268
 269 (define-electric-pair-test skip-single-quotes-in-ruby-mode
 270   " '' " "--'-" :skip-pair-string "--s-"
 271   :modes '(ruby-mode)
 272   :test-in-comments nil
 273   :test-in-strings nil
 274   :bindings `((electric-pair-text-syntax-table
 275                . ,prog-mode-syntax-table)))
 276
 277 (define-electric-pair-test leave-unbalanced-quotes-alone
 278   " \"' " "-\"'-" :skip-pair-string "----"
 279   :modes '(ruby-mode)
 280   :test-in-strings nil
 281   :bindings `((electric-pair-text-syntax-table
 282                . ,prog-mode-syntax-table)))
 283
 284 (define-electric-pair-test leave-unbalanced-quotes-alone-2
 285   " \"\\\"' " "-\"--'-" :skip-pair-string "------"
 286   :modes '(ruby-mode)
 287   :test-in-strings nil
 288   :bindings `((electric-pair-text-syntax-table
 289                . ,prog-mode-syntax-table)))
 290
 291 (define-electric-pair-test leave-unbalanced-quotes-alone-3
 292   " foo\\''" "'------" :skip-pair-string "-------"
 293   :modes '(ruby-mode)
 294   :test-in-strings nil
 295   :bindings `((electric-pair-text-syntax-table
 296                . ,prog-mode-syntax-table)))
 297
 298 (define-electric-pair-test inhibit-only-if-next-is-mismatched
 299   "\"foo\"\"bar" "\""
 300   :expected-string "\"\"\"foo\"\"bar"
 301   :expected-point 2
 302   :test-in-strings nil
 303   :bindings `((electric-pair-text-syntax-table
 304                . ,prog-mode-syntax-table)))
 305
 306 \f
 307 ;;; More quotes, but now don't bind `electric-pair-text-syntax-table'
 308 ;;; to `prog-mode-syntax-table'. Use the defaults for
 309 ;;; `electric-pair-pairs' and `electric-pair-text-pairs'.
 310 ;;;
 311 (define-electric-pair-test pairing-skipping-quotes-in-code
 312   " \"\"      " "-\"\"-----" :skip-pair-string "-ps------"
 313   :test-in-strings nil
 314   :test-in-comments nil)
 315
 316 (define-electric-pair-test skipping-quotes-in-comments
 317   " \"\"      " "--\"-----" :skip-pair-string "--s------"
 318   :test-in-strings nil)
 319
 320 \f
 321 ;;; Skipping over whitespace
 322 ;;;
 323 (define-electric-pair-test whitespace-jumping
 324   " (    )  " "--))))---" :expected-string " (    )  " :expected-point 8
 325   :bindings '((electric-pair-skip-whitespace . t)))
 326
 327 (define-electric-pair-test whitespace-chomping
 328   " (    )  " "--)------" :expected-string " ()  " :expected-point 4
 329   :bindings '((electric-pair-skip-whitespace . chomp)))
 330
 331 (define-electric-pair-test whitespace-chomping-2
 332   " ( \n\t\t\n  )  " "--)------" :expected-string " ()  " :expected-point 4
 333   :bindings '((electric-pair-skip-whitespace . chomp))
 334   :test-in-comments nil)
 335
 336 (define-electric-pair-test whitespace-chomping-dont-cross-comments
 337   " ( \n\t\t\n  )  " "--)------" :expected-string " () \n\t\t\n  )  "
 338   :expected-point 4
 339   :bindings '((electric-pair-skip-whitespace . chomp))
 340   :test-in-strings nil
 341   :test-in-code nil
 342   :test-in-comments t)
 343
 344 \f
 345 ;;; Pairing arbitrary characters
 346 ;;;
 347 (define-electric-pair-test angle-brackets-everywhere
 348   "<>" "<>" :skip-pair-string "ps"
 349   :bindings '((electric-pair-pairs . ((?\< . ?\>)))))
 350
 351 (define-electric-pair-test angle-brackets-everywhere-2
 352   "(<>" "-<>" :skip-pair-string "-ps"
 353   :bindings '((electric-pair-pairs . ((?\< . ?\>)))))
 354
 355 (defvar electric-pair-test-angle-brackets-table
 356   (let ((table (make-syntax-table prog-mode-syntax-table)))
 357     (modify-syntax-entry ?\< "(>" table)
 358     (modify-syntax-entry ?\> ")<`" table)
 359     table))
 360
 361 (define-electric-pair-test angle-brackets-pair
 362   "<>" "<" :expected-string "<><>" :expected-point 2
 363   :test-in-code nil
 364   :bindings `((electric-pair-text-syntax-table
 365                . ,electric-pair-test-angle-brackets-table)))
 366
 367 (define-electric-pair-test angle-brackets-skip
 368   "<>" "->" :expected-string "<>" :expected-point 3
 369   :test-in-code nil
 370   :bindings `((electric-pair-text-syntax-table
 371                . ,electric-pair-test-angle-brackets-table)))
 372
 373 (define-electric-pair-test pair-backtick-and-quote-in-comments
 374   ";; " "---`" :expected-string ";; `'" :expected-point 5
 375   :test-in-comments nil
 376   :test-in-strings nil
 377   :modes '(emacs-lisp-mode)
 378   :bindings '((electric-pair-text-pairs . ((?\` . ?\')))))
 379
 380 (define-electric-pair-test skip-backtick-and-quote-in-comments
 381   ";; `foo'" "-------'" :expected-string ";; `foo'" :expected-point 9
 382   :test-in-comments nil
 383   :test-in-strings nil
 384   :modes '(emacs-lisp-mode)
 385   :bindings '((electric-pair-text-pairs . ((?\` . ?\')))))
 386
 387 (define-electric-pair-test pair-backtick-and-quote-in-strings
 388   "\"\"" "-`" :expected-string "\"`'\"" :expected-point 3
 389   :test-in-comments nil
 390   :test-in-strings nil
 391   :modes '(emacs-lisp-mode)
 392   :bindings '((electric-pair-text-pairs . ((?\` . ?\')))))
 393
 394 (define-electric-pair-test skip-backtick-and-quote-in-strings
 395   "\"`'\"" "--'" :expected-string "\"`'\"" :expected-point 4
 396   :test-in-comments nil
 397   :test-in-strings nil
 398   :modes '(emacs-lisp-mode)
 399   :bindings '((electric-pair-text-pairs . ((?\` . ?\')))))
 400
 401 (define-electric-pair-test skip-backtick-and-quote-in-strings-2
 402   "  \"`'\"" "----'" :expected-string "  \"`'\"" :expected-point 6
 403   :test-in-comments nil
 404   :test-in-strings nil
 405   :modes '(emacs-lisp-mode)
 406   :bindings '((electric-pair-text-pairs . ((?\` . ?\')))))
 407
 408 \f
 409 ;;; `js-mode' has `electric-layout-rules' for '{ and '}
 410 ;;;
 411 (define-electric-pair-test js-mode-braces
 412   "" "{" :expected-string "{}" :expected-point 2
 413   :modes '(js-mode)
 414   :fixture-fn #'(lambda ()
 415                   (electric-pair-mode 1)))
 416
 417 (define-electric-pair-test js-mode-braces-with-layout
 418   "" "{" :expected-string "{\n\n}" :expected-point 3
 419   :modes '(js-mode)
 420   :test-in-comments nil
 421   :test-in-strings nil
 422   :fixture-fn #'(lambda ()
 423                   (electric-layout-mode 1)
 424                   (electric-pair-mode 1)))
 425
 426 (define-electric-pair-test js-mode-braces-with-layout-and-indent
 427   "" "{" :expected-string "{\n    \n}" :expected-point 7
 428   :modes '(js-mode)
 429   :test-in-comments nil
 430   :test-in-strings nil
 431   :fixture-fn #'(lambda ()
 432                   (electric-pair-mode 1)
 433                   (electric-indent-mode 1)
 434                   (electric-layout-mode 1)))
 435
 436 \f
 437 ;;; Backspacing
 438 ;;; TODO: better tests
 439 ;;;
 440 (ert-deftest electric-pair-backspace-1 ()
 441   (save-electric-modes
 442     (with-temp-buffer
 443       (insert "()")
 444       (goto-char 2)
 445       (electric-pair-backward-delete-char 1)
 446       (should (equal "" (buffer-string))))))
 447
 448 \f
 449 ;;; Electric newlines between pairs
 450 ;;; TODO: better tests
 451 (ert-deftest electric-pair-open-extra-newline ()
 452   (save-electric-modes
 453     (with-temp-buffer
 454       (c-mode)
 455       (electric-pair-mode 1)
 456       (electric-indent-mode 1)
 457       (insert "int main {}")
 458       (backward-char 1)
 459       (let ((c-basic-offset 4))
 460         (newline 1 t)
 461         (should (equal "int main {\n    \n}"
 462                        (buffer-string)))
 463         (should (equal (point) (- (point-max) 2)))))))
 464
 465
 466 \f
 467 ;;; Autowrapping
 468 ;;;
 469 (define-electric-pair-test autowrapping-1
 470   "foo" "(" :expected-string "(foo)" :expected-point 2
 471   :fixture-fn #'(lambda ()
 472                   (electric-pair-mode 1)
 473                   (mark-sexp 1)))
 474
 475 (define-electric-pair-test autowrapping-2
 476   "foo" ")" :expected-string "(foo)" :expected-point 6
 477   :fixture-fn #'(lambda ()
 478                   (electric-pair-mode 1)
 479                   (mark-sexp 1)))
 480
 481 (define-electric-pair-test autowrapping-3
 482   "foo" ")" :expected-string "(foo)" :expected-point 6
 483   :fixture-fn #'(lambda ()
 484                   (electric-pair-mode 1)
 485                   (goto-char (point-max))
 486                   (skip-chars-backward "\"")
 487                   (mark-sexp -1)))
 488
 489 (define-electric-pair-test autowrapping-4
 490   "foo" "(" :expected-string "(foo)" :expected-point 2
 491   :fixture-fn #'(lambda ()
 492                   (electric-pair-mode 1)
 493                   (goto-char (point-max))
 494                   (skip-chars-backward "\"")
 495                   (mark-sexp -1)))
 496
 497 (define-electric-pair-test autowrapping-5
 498   "foo" "\"" :expected-string "\"foo\"" :expected-point 2
 499   :fixture-fn #'(lambda ()
 500                   (electric-pair-mode 1)
 501                   (mark-sexp 1)))
 502
 503 (define-electric-pair-test autowrapping-6
 504   "foo" "\"" :expected-string "\"foo\"" :expected-point 6
 505   :fixture-fn #'(lambda ()
 506                   (electric-pair-mode 1)
 507                   (goto-char (point-max))
 508                   (skip-chars-backward "\"")
 509                   (mark-sexp -1)))
 510
 511 (provide 'electric-tests)
 512 ;;; electric-tests.el ends here