[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[nongnu] elpa/evil-goggles c6935dc53d 099/225: Don't bundle evil-tests.e
From: |
ELPA Syncer |
Subject: |
[nongnu] elpa/evil-goggles c6935dc53d 099/225: Don't bundle evil-tests.el. Fix #15 |
Date: |
Wed, 12 Jan 2022 08:58:59 -0500 (EST) |
branch: elpa/evil-goggles
commit c6935dc53df69316003fd0dcdb6918c69e245d1e
Author: Evgeni Kolev <evgenysw@gmail.com>
Commit: Evgeni Kolev <evgenysw@gmail.com>
Don't bundle evil-tests.el. Fix #15
---
.travis.yml | 1 -
Makefile | 3 -
test/evil-tests.el | 8185 ----------------------------------------------------
3 files changed, 8189 deletions(-)
diff --git a/.travis.yml b/.travis.yml
index 67d51dac26..73853ab93e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,4 +14,3 @@ script:
- make update
- make compile
- make test
- - make evil-test-batch
diff --git a/Makefile b/Makefile
index 55bef7b75e..a0948245f1 100644
--- a/Makefile
+++ b/Makefile
@@ -22,7 +22,4 @@ wget-evil-tests:
evil-test:
$(emacs) -nw -Q -l test/elpa.el -l test/make-evil-test.el
-evil-test-batch:
- $(bemacs) -l test/make-evil-test.el
-
.PHONY: update compile test clean checkdoc evil-test wget-evil-tests
evil-test-batch
diff --git a/test/evil-tests.el b/test/evil-tests.el
deleted file mode 100644
index 03db2db75a..0000000000
--- a/test/evil-tests.el
+++ /dev/null
@@ -1,8185 +0,0 @@
-;; evil-tests.el --- unit tests for Evil -*- coding: utf-8 -*-
-
-;; Author: Vegard Øye <vegard_oye at hotmail.com>
-;; Maintainer: Vegard Øye <vegard_oye at hotmail.com>
-
-;; Version: 1.2.12
-
-;;
-;; This file is NOT part of GNU Emacs.
-
-;;; License:
-
-;; This file is part of Evil.
-;;
-;; Evil 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.
-;;
-;; Evil 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 Evil. If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file is for developers. It runs some tests on Evil.
-;; To load it, run the Makefile target "make test" or add
-;; the following lines to .emacs:
-;;
-;; (setq evil-tests-run nil) ; set to t to run tests immediately
-;; (global-set-key [f12] 'evil-tests-run) ; hotkey
-;; (require 'evil-tests)
-;;
-;; Loading this file enables profiling on Evil. The current numbers
-;; can be displayed with `elp-results'. The Makefile target
-;; "make profiler" shows profiling results in the terminal on the
-;; basis of running all tests.
-;;
-;; To write a test, use `ert-deftest' and specify a :tags value of at
-;; least '(evil). The test may inspect the output of functions given
-;; certain input, or it may execute a key sequence in a temporary
-;; buffer and investigate the results. For the latter approach, the
-;; macro `evil-test-buffer' creates a temporary buffer in Normal
-;; state. String descriptors initialize and match the contents of
-;; the buffer:
-;;
-;; (ert-deftest evil-test ()
-;; :tags '(evil)
-;; (evil-test-buffer
-;; "[T]his creates a test buffer." ; cursor on "T"
-;; ("w") ; key sequence
-;; "This [c]reates a test buffer."))) ; cursor moved to "c"
-;;
-;; The initial state, the cursor syntax, etc., can be changed
-;; with keyword arguments. See the documentation string of
-;; `evil-test-buffer' for more details.
-;;
-;; This file is NOT part of Evil itself.
-
-(require 'elp)
-(require 'ert)
-(require 'evil)
-(require 'evil-test-helpers)
-
-;;; Code:
-
-(defvar evil-tests-run nil
- "*Run Evil tests.")
-
-(defvar evil-tests-profiler nil
- "*Profile Evil tests.")
-
-(defun evil-tests-initialize (&optional tests profiler interactive)
- (setq profiler (or profiler evil-tests-profiler))
- (when (listp profiler)
- (setq profiler (car profiler)))
- (when profiler
- (setq evil-tests-profiler t)
- (setq profiler
- (or (cdr (assq profiler
- '((call . elp-sort-by-call-count)
- (average . elp-sort-by-average-time)
- (total . elp-sort-by-total-time))))))
- (setq elp-sort-by-function (or profiler 'elp-sort-by-call-count))
- (elp-instrument-package "evil"))
- (if interactive
- (if (y-or-n-p-with-timeout "Run tests? " 2 t)
- (evil-tests-run tests interactive)
- (message "You can run the tests at any time \
-with `M-x evil-tests-run'"))
- (evil-tests-run tests)))
-
-(defun evil-tests-run (&optional tests interactive)
- "Run Evil tests."
- (interactive '(nil t))
- (let ((elp-use-standard-output (not interactive)))
- (setq tests
- (or (null tests)
- `(or ,@(mapcar #'(lambda (test)
- (or (null test)
- (and (memq test '(evil t)) t)
- `(or (tag ,test)
- ,(format "^%s$" test))))
- tests))))
- (cond
- (interactive
- (ert-run-tests-interactively tests)
- (when evil-tests-profiler
- (elp-results)))
- (evil-tests-profiler
- (ert-run-tests-batch tests)
- (elp-results))
- (t
- (ert-run-tests-batch-and-exit tests)))))
-
-(defun evil-tests-profiler (&optional force)
- "Profile Evil tests."
- (when (or evil-tests-profiler force)
- (setq evil-tests-profiler t)
- (elp-instrument-package "evil")))
-
-
-;;; States
-
-(defun evil-test-local-mode-enabled ()
- "Verify that `evil-local-mode' is enabled properly"
- (ert-info ("Set the mode variable to t")
- (should (eq evil-local-mode t)))
- (ert-info ("Refresh `emulation-mode-map-alist'")
- (should (memq 'evil-mode-map-alist emulation-mode-map-alists)))
- (ert-info ("Create a buffer-local value for `evil-mode-map-alist'")
- (should (assq 'evil-mode-map-alist (buffer-local-variables))))
- (ert-info ("Initialize buffer-local keymaps")
- (should (assq 'evil-normal-state-local-map (buffer-local-variables)))
- (should (keymapp evil-normal-state-local-map))
- (should (assq 'evil-emacs-state-local-map (buffer-local-variables)))
- (should (keymapp evil-emacs-state-local-map)))
- (ert-info ("Don't add buffer-local entries to the default value")
- (should-not (rassq evil-normal-state-local-map
- (default-value 'evil-mode-map-alist)))
- (should-not (rassq evil-emacs-state-local-map
- (default-value 'evil-mode-map-alist)))))
-
-(defun evil-test-local-mode-disabled ()
- "Verify that `evil-local-mode' is disabled properly"
- (ert-info ("Set the mode variable to nil")
- (should-not evil-local-mode))
- (ert-info ("Disable all states")
- (evil-test-no-states)))
-
-(defun evil-test-no-states ()
- "Verify that all states are disabled"
- (ert-info ("Set `evil-state' to nil")
- (should-not evil-state))
- (ert-info ("Disable all state keymaps")
- (dolist (state (mapcar #'car evil-state-properties) t)
- (should-not (evil-state-property state :mode t))
- (should-not (memq (evil-state-property state :keymap t)
- (current-active-maps)))
- (should-not (evil-state-property state :local t))
- (should-not (memq (evil-state-property state :local-keymap t)
- (current-active-maps)))
- (dolist (map (evil-state-auxiliary-keymaps state))
- (should-not (memq map (current-active-maps)))))))
-
-(ert-deftest evil-test-toggle-local-mode ()
- "Toggle `evil-local-mode'"
- :tags '(evil state)
- (with-temp-buffer
- (ert-info ("Enable `evil-local-mode'")
- (evil-local-mode 1)
- (evil-test-local-mode-enabled))
- (ert-info ("Disable `evil-local-mode'")
- (evil-local-mode -1)
- (evil-test-local-mode-disabled))))
-
-(defun evil-test-change-state (state)
- "Change state to STATE and check keymaps"
- (let (mode keymap local-mode local-keymap tag)
- (evil-change-state state)
- (setq mode (evil-state-property state :mode)
- keymap (evil-state-property state :keymap t)
- local-mode (evil-state-property state :local)
- local-keymap (evil-state-property state :local-keymap t)
- tag (evil-state-property state :tag t))
- (ert-info ("Update `evil-state'")
- (should (eq evil-state state)))
- (ert-info ("Ensure `evil-local-mode' is enabled")
- (evil-test-local-mode-enabled))
- (ert-info ("Enable state modes")
- (should (symbol-value mode))
- (should (symbol-value local-mode)))
- (ert-info ("Push state keymaps to the top")
- (evil-test-state-keymaps state))
- (ert-info ("Refresh mode line tag")
- (should (equal evil-mode-line-tag tag)))))
-
-(defun evil-test-state-keymaps (state)
- "Verify that STATE's keymaps are pushed to the top"
- (let ((actual (evil-state-keymaps state))
- (expected `((,(evil-state-property state :local)
- . , (evil-state-property state :local-keymap t))
- (,(evil-state-property state :mode)
- . ,(evil-state-property state :keymap t)))))
- ;; additional keymaps inherited with :enable
- (cond
- ((eq state 'operator)
- (setq expected
- `((evil-operator-shortcut-mode
- . ,evil-operator-shortcut-map)
- (evil-operator-state-local-minor-mode
- . ,evil-operator-state-local-map)
- (evil-operator-state-minor-mode
- . ,evil-operator-state-map)
- (evil-motion-state-local-minor-mode
- . ,evil-motion-state-local-map)
- (evil-motion-state-minor-mode
- . ,evil-motion-state-map)
- (evil-normal-state-local-minor-mode
- . ,evil-normal-state-local-map)
- (evil-normal-state-minor-mode
- . ,evil-normal-state-map)))))
- (let ((actual (butlast actual (- (length actual)
- (length expected)))))
- (should (equal actual expected))
- (dolist (map actual)
- (setq map (cdr-safe map))
- (should (keymapp map))))))
-
-(ert-deftest evil-test-exit-normal-state ()
- "Enter Normal state and then disable all states"
- :tags '(evil state)
- (with-temp-buffer
- (evil-test-change-state 'normal)
- (evil-normal-state -1)
- (evil-test-no-states)))
-
-(ert-deftest evil-test-change-states ()
- "Change between Normal state, Emacs state and Operator-Pending state"
- :tags '(evil state)
- (with-temp-buffer
- (evil-test-change-state 'normal)
- (evil-test-change-state 'emacs)
- (evil-test-change-state 'normal)
- (evil-test-change-state 'operator)
- (evil-test-change-state 'normal)
- (evil-test-change-state 'emacs)
- (evil-test-change-state 'replace)
- (evil-test-change-state 'normal)))
-
-(ert-deftest evil-test-change-to-previous-state ()
- "Change to some state and back."
- :tags '(evil state)
- (with-temp-buffer
- (evil-test-change-state 'normal)
- (evil-test-change-state 'visual)
- (evil-test-change-state 'emacs)
- (evil-change-to-previous-state)
- (should (eq evil-state 'visual))
- (evil-change-to-previous-state)
- (should (eq evil-state 'normal))))
-
-(ert-deftest evil-test-enter-normal-state-disabled ()
- "Enter Normal state even if `evil-local-mode' is disabled"
- :tags '(evil state)
- (with-temp-buffer
- (evil-local-mode -1)
- (evil-test-local-mode-disabled)
- (evil-test-change-state 'normal)))
-
-(ert-deftest evil-test-execute-in-normal-state ()
- "Test `evil-execute-in-normal-state'."
- :tags '(evil)
- (ert-info ("Execute normal state command in insert state")
- (evil-test-buffer
- "[a]bcdef\n"
- ("I")
- (should (evil-insert-state-p))
- ("\C-ox")
- (ert-info ("Should return to insert state")
- (should (evil-insert-state-p)))
- "[b]cdef\n"
- ("\C-oA")
- (ert-info ("Should return to insert state after insert state command")
- (should (evil-insert-state-p)))
- ("bcdef[]\n"))))
-
-(defun evil-test-suppress-keymap (state)
- "Verify that `self-insert-command' is suppressed in STATE"
- (evil-test-buffer
- ";; This buffer is for notes."
- (evil-test-change-state state)
- ;; TODO: this should be done better
- (ert-info ("Disable the state's own keymaps so that the
-suppression keymap comes first")
- (setq evil-operator-state-minor-mode nil
- evil-operator-state-local-minor-mode nil))
- (should (eq (key-binding "Q") #'undefined))
- (ert-info ("Don't insert text")
- ;; may or may not signal an error, depending on batch mode
- (condition-case nil
- (execute-kbd-macro "QQQ")
- (error nil))
- (should (string= (buffer-substring 1 4) ";; ")))))
-
-(ert-deftest evil-test-emacs-state-suppress-keymap ()
- "`self-insert-command' works in Emacs state"
- :tags '(evil state)
- (should-error (evil-test-suppress-keymap 'emacs)))
-
-(ert-deftest evil-test-normal-state-suppress-keymap ()
- "No `self-insert-command' in Normal state"
- :tags '(evil state)
- (evil-test-suppress-keymap 'normal))
-
-(ert-deftest evil-test-operator-state-suppress-keymap ()
- "Operator-Pending state should inherit suppression
-of `self-insert-command' from Normal state"
- :tags '(evil state)
- (evil-test-suppress-keymap 'operator))
-
-(ert-deftest evil-test-operator-state-shortcut-keymap ()
- "Enable shortcut keymap in Operator-Pending state"
- :tags '(evil state)
- (evil-test-buffer
- (ert-info ("Activate `evil-operator-shortcut-map' in \
-Operator-Pending state")
- (evil-test-change-state 'operator)
- (should (rassq evil-operator-shortcut-map
- (evil-state-keymaps 'operator)))
- (should (keymapp evil-operator-shortcut-map))
- (should evil-operator-shortcut-mode)
- (should (memq evil-operator-shortcut-map
- (current-active-maps))))
- (ert-info ("Deactivate `evil-operator-shortcut-map' \
-outside Operator-Pending state")
- (evil-test-change-state 'emacs)
- (should-not evil-operator-shortcut-mode)
- (should-not (memq evil-operator-shortcut-map
- (current-active-maps))))
- (ert-info ("Reset `evil-operator-shortcut-map' \
-when entering Operator-Pending state")
- (define-key evil-operator-shortcut-map "f" 'foo)
- (should (eq (lookup-key evil-operator-shortcut-map "f")
- 'foo))
- (evil-test-change-state 'operator)
- (should-not (eq (lookup-key evil-operator-shortcut-map "f")
- 'foo)))
- (ert-info ("Reset `evil-operator-shortcut-map' \
-when exiting Operator-Pending state")
- (define-key evil-operator-shortcut-map "b" 'bar)
- (should (eq (lookup-key evil-operator-shortcut-map "b")
- 'bar))
- (evil-test-change-state 'emacs)
- (should-not (eq (lookup-key evil-operator-shortcut-map "b")
- 'bar)))))
-
-(ert-deftest evil-test-auxiliary-maps ()
- "Test auxiliary keymaps"
- :tags '(evil state)
- (let ((map (make-sparse-keymap)) aux)
- (ert-info ("Create a new auxiliary keymap")
- (evil-define-key 'normal map "f" 'foo)
- (setq aux (evil-get-auxiliary-keymap map 'normal))
- (should (evil-auxiliary-keymap-p aux))
- (should (eq (lookup-key aux "f") 'foo)))
- (ert-info ("Add to auxiliary keymap")
- (evil-define-key 'normal map "b" 'bar)
- (should (eq (lookup-key aux "f") 'foo))
- (should (eq (lookup-key aux "b") 'bar)))))
-
-;;; Type system
-
-(ert-deftest evil-test-exclusive-type ()
- "Expand and contract the `line' type"
- :tags '(evil type)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (let* ((first-line 1)
- (second-line (progn
- (forward-line)
- (point)))
- (third-line (progn
- (forward-line)
- (point))))
- (ert-info ("Return the beginning and end unchanged \
-if they are the same")
- (should (equal (evil-normalize 1 1 'exclusive)
- (list 1 1 'exclusive))))
- (ert-info ("expand to `inclusive' if the end position \
-is at the beginning of a line")
- (should (equal (evil-normalize (1+ first-line) second-line 'exclusive)
- (list (1+ first-line) (1- second-line) 'inclusive
- :expanded t))))
- (ert-info ("expand to `line' if both the beginning and end \
-are at the beginning of a line")
- (should (equal (evil-normalize first-line second-line 'exclusive)
- (list first-line second-line 'line
- :expanded t))))
- (ert-info ("Measure as the strict difference between the end \
-and the beginning")
- (should (string= (evil-describe 1 1 'exclusive)
- "0 characters"))
- (should (string= (evil-describe 1 2 'exclusive)
- "1 character"))
- (should (string= (evil-describe 5 2 'exclusive)
- "3 characters"))))))
-
-(ert-deftest evil-test-inclusive-type ()
- "Expand and contract the `inclusive' type"
- :tags '(evil type)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (ert-info ("Include the ending character")
- (should (equal (evil-expand 1 1 'inclusive)
- '(1 2 inclusive :expanded t))))
- (ert-info ("Don't mind if positions are in wrong order")
- (should (equal (evil-expand 5 2 'inclusive)
- '(2 6 inclusive :expanded t))))
- (ert-info ("Exclude the ending character when contracting")
- (should (equal (evil-contract 1 2 'inclusive)
- '(1 1 inclusive :expanded nil))))
- (ert-info ("Don't mind positions' order when contracting")
- (should (equal (evil-contract 6 2 'inclusive)
- '(2 5 inclusive :expanded nil))))
- (ert-info ("Measure as one more than the difference")
- (should (string= (evil-describe 1 1 'inclusive)
- "1 character"))
- (should (string= (evil-describe 5 2 'inclusive)
- "4 characters")))))
-
-(ert-deftest evil-test-line-type ()
- "Expand the `line' type"
- :tags '(evil type)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (let* ((first-line 1)
- (second-line (progn
- (forward-line)
- (point)))
- (third-line (progn
- (forward-line)
- (point))))
- (ert-info ("Expand to the whole first line")
- (should (equal (evil-expand first-line first-line 'line)
- (list first-line second-line 'line :expanded t)))
- (should (string= (evil-describe first-line first-line 'line)
- "1 line")))
- (ert-info ("Expand to the two first lines")
- (should (equal (evil-expand first-line second-line 'line)
- (list first-line third-line 'line :expanded t)))
- (should (string= (evil-describe first-line second-line 'line)
- "2 lines"))))))
-
-(ert-deftest evil-test-block-type ()
- "Expand and contract the `block' type"
- :tags '(evil type)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (let* ((first-line 1)
- (second-line (progn
- (forward-line)
- (point)))
- (third-line (progn
- (forward-line)
- (point))))
- (ert-info ("Expand to a 1x1 block")
- (should (equal (evil-expand 1 1 'block)
- (list 1 2 'block :expanded t)))
- (should (string= (evil-describe 1 1 'block)
- "1 row and 1 column")))
- (ert-info ("Expand to a 2x1 block")
- (should (equal (evil-expand first-line second-line 'block)
- (list first-line (1+ second-line) 'block :expanded t)))
- (should (string= (evil-describe first-line second-line 'block)
- "2 rows and 1 column")))
- (ert-info ("Expand to a 3x2 block")
- (should (equal (evil-expand first-line (1+ third-line) 'block)
- (list first-line (1+ (1+ third-line))
- 'block :expanded t)))
- (should (string= (evil-describe first-line (1+ third-line) 'block)
- "3 rows and 2 columns")))
- (ert-info ("Contract to a 0x0 rectangle")
- (should (equal (evil-contract 1 2 'block)
- (list 1 1 'block :expanded nil))))
- (ert-info ("Contract to a 2x0 rectangle")
- (should (equal (evil-contract first-line (1+ second-line) 'block)
- (list first-line second-line 'block :expanded nil))))
- (ert-info ("Contract to a 3x1 rectangle")
- (should (equal (evil-contract first-line (1+ (1+ third-line)) 'block)
- (list first-line (1+ third-line)
- 'block :expanded nil)))))))
-
-(ert-deftest evil-test-type-transform ()
- "Test `evil-transform'"
- :tags '(evil type)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (ert-info ("Return positions unchanged when passed nil \
-for TYPE or TRANSFORM")
- (should (equal (evil-transform nil 1 2 'block)
- '(1 2 block)))
- (should (equal (evil-transform :expand 1 2 nil)
- '(1 2)))
- (should (equal (evil-transform nil 1 2 nil)
- '(1 2))))
- (ert-info ("Accept markers, but return positions")
- (should (equal (evil-transform :expand
- (move-marker (make-marker) 1) 1
- 'inclusive)
- '(1 2 inclusive :expanded t)))
- (should (equal (evil-transform nil (move-marker (make-marker) 1) 2
- nil)
- '(1 2))))))
-
-(ert-deftest evil-test-type-modifiers ()
- "Test type modifiers like \"dv}\""
- :tags '(evil type)
- (ert-info ("Change `inclusive' motions to `exclusive'")
- (evil-test-buffer
- "[A]bove some line"
- ("dve")
- "[e] some line"))
- (ert-info ("Change `exclusive' motions to `inclusive'")
- (evil-test-buffer
- "Above [s]ome line
-
-Below some empty line"
- ("dv}")
- "Above[ ]
-Below some empty line"))
- (ert-info ("Change type to `line'")
- (evil-test-buffer
- "Above [s]ome line
-
-Below some empty line"
- ("dV}")
- "[B]elow some empty line")))
-
-;;; Insertion
-
-(ert-deftest evil-test-insert ()
- "Test `evil-insert'"
- :tags '(evil insert)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save"
- ("ievil rulz " [escape])
- ";; evil rulz[ ]This buffer is for notes you don't want to save"))
-
-(ert-deftest evil-test-append ()
- "Test `evil-append'"
- :tags '(evil insert)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save"
- ("aevil rulz " [escape])
- ";; Tevil rulz[ ]his buffer is for notes you don't want to save"))
-
-(ert-deftest evil-test-open-above ()
- "Test `evil-open-above'"
- :tags '(evil insert)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("Oabc\ndef" [escape])
- ";; This buffer is for notes you don't want to save,
-abc
-de[f]
-;; and for Lisp evaluation.")
- (ert-info ("Open empty line")
- (evil-test-buffer
- "(let (var)\n [t]est)\n"
- (emacs-lisp-mode)
- ("O" [escape])
- "(let (var)\n[\n] test)\n"))
- (ert-info ("Open non-empty line")
- (evil-test-buffer
- "(let (var)\n [t]est)\n"
- (emacs-lisp-mode)
- ("Odo-it" [escape])
- "(let (var)\n do-i[t]\n test)\n")))
-
-(ert-deftest evil-test-open-below ()
- "Test `evil-open-below'"
- :tags '(evil insert)
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("oabc\ndef" [escape])
- ";; This buffer is for notes you don't want to save,
-abc
-de[f]
-;; and for Lisp evaluation.")
- (ert-info ("Open empty line")
- (evil-test-buffer
- "[(]let (var)\n test)\n"
- (emacs-lisp-mode)
- ("o" [escape])
- "(let (var)\n[\n] test)\n"))
- (ert-info ("Open non-empty line")
- (evil-test-buffer
- "[(]let (var)\n test)\n"
- (emacs-lisp-mode)
- ("odo-it" [escape])
- "(let (var)\n do-i[t]\n test)\n"))
- (let ((evil-auto-indent t))
- (ert-info ("With count")
- (evil-test-buffer
- "[(]and a\n c)\n"
- (emacs-lisp-mode)
- ("3ob" [escape])
- "(and a\n b\n b\n [b]\n c)\n"))))
-
-(ert-deftest evil-test-open-below-folded ()
- "Test `evil-open-below' on folded lines"
- :tags '(evil insert)
- (evil-test-buffer
- "[l]ine1\n\n(let ()\n var)\n\nlast line\n"
- (emacs-lisp-mode)
- (hs-minor-mode 1)
- ("zm2joABC" [escape])
- "line1\n\n(let ()\n var)\nAB[C]\n\nlast line\n"))
-
-(ert-deftest evil-test-insert-line ()
- "Test `evil-insert-line'"
- :tags '(evil insert)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save"
- ("Ievil rulz " [escape])
- "evil rulz[ ];; This buffer is for notes you don't want to save"))
-
-(ert-deftest evil-test-append-line ()
- "Test `evil-append-line'"
- :tags '(evil insert)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save"
- ("Aevil rulz " [escape])
- ";; This buffer is for notes you don't want to saveevil rulz[ ]"))
-
-(ert-deftest evil-test-insert-digraph ()
- "Test `evil-insert-digraph'"
- :tags '(evil insert)
- (ert-info ("Predefined digraph")
- (evil-test-buffer
- ("i\C-kae")
- "æ[]"))
- (ert-info ("Custom digraph")
- (let ((evil-digraphs-table-user '(((?a ?o) . ?å))))
- (evil-test-buffer
- ("i\C-kao")
- "å[]"))))
-
-;;; Repeat system
-
-(ert-deftest evil-test-normalize-repeat-info ()
- "Test `evil-normalize-repeat-info'"
- :tags '(evil repeat)
- (ert-info ("Single array")
- (should (equal (evil-normalize-repeat-info
- '("abc"))
- '([?a ?b ?c])))
- (should (equal (evil-normalize-repeat-info
- '("\M-f"))
- (list (kbd "M-f")))))
- (ert-info ("Single symbol")
- (should (equal (evil-normalize-repeat-info
- '(SYM))
- '(SYM))))
- (ert-info ("Arrays only")
- (should (equal (evil-normalize-repeat-info
- '("abc" [XX YY] "def"))
- '([?a ?b ?c XX YY ?d ?e ?f]))))
- (ert-info ("Several symbols")
- (should (equal (evil-normalize-repeat-info
- '(BEG MID END))
- '(BEG MID END))))
- (ert-info ("Arrays with symbol at the beginning")
- (should (equal (evil-normalize-repeat-info
- '(BEG "abc" [XX YY] "def"))
- '(BEG [?a ?b ?c XX YY ?d ?e ?f]))))
- (ert-info ("Arrays with symbol at the end")
- (should (equal (evil-normalize-repeat-info
- '("abc" [XX YY] "def" END))
- '([?a ?b ?c XX YY ?d ?e ?f] END))))
- (ert-info ("Arrays with symbol in the middle")
- (should (equal (evil-normalize-repeat-info
- '("abc" [XX YY] MID "def" ))
- '([?a ?b ?c XX YY] MID [?d ?e ?f]))))
- (ert-info ("Concatenate arrays with several symbols")
- (should (equal (evil-normalize-repeat-info
- '(BEG "abc" [XX YY] MID "def" END))
- '(BEG [?a ?b ?c XX YY] MID [?d ?e ?f] END)))))
-
-(defun evil-test-repeat-info (keys &optional recorded)
- "Execute a sequence of keys and verify that `evil-repeat-ring'
-records them correctly. KEYS is the sequence of keys to execute.
-RECORDED is the expected sequence of recorded events.
-If nil, KEYS is used."
- (execute-kbd-macro keys)
- (should (equal (evil-normalize-repeat-info (ring-ref evil-repeat-ring 0))
- (list (vconcat (or recorded keys))))))
-
-(ert-deftest evil-test-normal-repeat-info-simple-command ()
- "Save key-sequence after simple editing command in Normal state"
- :tags '(evil repeat)
- (evil-test-buffer
- "[T]his is a test buffer"
- (ert-info ("Call simple command without count")
- (evil-test-repeat-info "x"))
- (ert-info ("Call simple command with count 3")
- (evil-test-repeat-info "3x"))))
-
-(ert-deftest evil-test-normal-repeat-info-char-command ()
- "Save key-sequence after editing command with character in Normal state"
- :tags '(evil repeat)
- (evil-test-buffer
- "[T]his is a test buffer"
- (ert-info ("Call command with character argument without count")
- (evil-test-repeat-info "r5"))
- (ert-info ("Call command with character argument with count 12")
- (evil-test-repeat-info "12rX"))))
-
-(ert-deftest evil-test-insert-repeat-info ()
- "Save key-sequence after Insert state"
- :tags '(evil repeat)
- (evil-test-buffer
- (ert-info ("Insert text without count")
- (evil-test-repeat-info (vconcat "iABC" [escape])))
- (ert-info ("Insert text with count 42")
- (evil-test-repeat-info (vconcat "42iABC" [escape])))))
-
-(ert-deftest evil-test-repeat ()
- "Repeat several editing commands"
- :tags '(evil repeat)
- (ert-info ("Repeat replace")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("rX")
- "[X]; This buffer is for notes you don't want to save"
- ([right right] ".")
- "X;[X]This buffer is for notes you don't want to save"))
- (ert-info ("Repeat replace with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("2rX")
- "X[X] This buffer is for notes you don't want to save"
- ([right right] ".")
- "XX X[X]is buffer is for notes you don't want to save"))
- (ert-info ("Repeat replace without count with a new count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("rX")
- "[X]; This buffer is for notes you don't want to save"
- ([right right] "13.")
- "X;XXXXXXXXXXXX[X]is for notes you don't want to save"))
- (ert-info ("Repeat replace with count replacing original count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("10rX")
- "XXXXXXXXX[X]ffer is for notes you don't want to save"
- ([right right] "20.")
- "XXXXXXXXXXfXXXXXXXXXXXXXXXXXXX[X] don't want to save"))
- (ert-info ("Repeat movement in Insert state")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save"
- ("i(\M-f)" [escape])
- ";; (This[)] buffer is for notes you don't want to save"
- ("w.")
- ";; (This) (buffer[)] is for notes you don't want to save")))
-
-(ert-deftest evil-test-repeat-register ()
- "Test repeating a register command."
- :tags '(evil repeat)
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4\n"
- ("\"addyy\"aP")
- "[l]ine 1\nline 2\nline 3\nline 4\n"
- (".")
- "[l]ine 1\nline 1\nline 2\nline 3\nline 4\n"))
-
-(ert-deftest evil-test-repeat-numeric-register ()
- "Test repeating a command with a numeric register."
- :tags '(evil repeat)
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4\nline 5\n"
- ("dd...")
- "[l]ine 5\n"
- ("\"1P")
- "[l]ine 4\nline 5\n"
- (".")
- "[l]ine 3\nline 4\nline 5\n"
- (".")
- "[l]ine 2\nline 3\nline 4\nline 5\n"
- (".")
- "[l]ine 1\nline 2\nline 3\nline 4\nline 5\n"))
-
-(ert-deftest evil-test-cmd-replace-char ()
- "Calling `evil-replace-char' should replace characters"
- :tags '(evil repeat)
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("r5")
- "[5]; This buffer is for notes you don't want to save"
- ("3rX")
- "XX[X]This buffer is for notes you don't want to save")
- (ert-info ("Replace digraph")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save"
- ("re'")
- "[é]; This buffer is for notes you don't want to save"
- ("3rc*")
- "ξξ[ξ]This buffer is for notes you don't want to save"))
- (ert-info ("Replacing \\n should insert only one newline")
- (evil-test-buffer
- "(setq var xxx [y]yy zzz)\n"
- (emacs-lisp-mode)
- (setq indent-tabs-mode nil)
- ("2r\n")
- "(setq var xxx \n [y] zzz)\n")))
-
-(ert-deftest evil-test-insert-with-count ()
- "Test `evil-insert' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes"
- ("2ievil rulz " [escape])
- ";; evil rulz evil rulz[ ]This buffer is for notes"))
-
-(ert-deftest evil-test-repeat-insert ()
- "Test repeating of `evil-insert'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("iABC" [escape])
- "AB[C];; This buffer is for notes"
- ("..")
- "ABABAB[C]CC;; This buffer is for notes"))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("2iABC" [escape])
- "ABCAB[C];; This buffer is for notes"
- ("..")
- "ABCABABCABABCAB[C]CC;; This buffer is for notes"))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("iABC" [escape])
- "AB[C];; This buffer is for notes"
- ("11.")
- "ABABCABCABCABCABCABCABCABCABCABCAB[C]C;; This buffer is for notes"))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("10iABC" [escape])
- "ABCABCABCABCABCABCABCABCABCAB[C];; This buffer is for notes"
- ("11.")
- "ABCABCABCABCABCABCABCABCABCABABCABCABCABCABCABCABCABCABCABCAB[C]C;; \
-This buffer is for notes")))
-
-(ert-deftest evil-test-repeat-error ()
- "Test whether repeat returns to normal state in case of an error."
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- ("ixxx" [down] [down] [left] [left] [left] "yyy" [escape])
- "xxxline 1\nline 2\nyy[y]line 3\nline 4"
- (should-error (execute-kbd-macro "j^."))
- (should (evil-normal-state-p))
- ("^")
- "xxxline 1\nline 2\nyyyline 3\n[x]xxline 4"))
-
-(ert-deftest evil-test-repeat-quoted-insert ()
- "Test whether `quoted-insert' can be repeated."
- (ert-info ("Insert C-v")
- (evil-test-buffer
- "lin[e] 1\nline 2\nline 3\n"
- ("i\C-v\C-v" [escape])
- "lin[]e 1\nline 2\nline 3\n"))
- (ert-info ("Insert ESC")
- (evil-test-buffer
- "lin[e] 1\nline 2\nline 3\n"
- ("i\C-v" [escape escape])
- "lin[]e 1\nline 2\nline 3\n"))
- (ert-info ("Block insert C-v")
- (evil-test-buffer
- "lin[e] 1\nline 2\nline 3\n"
- ("gg\C-vGI\C-v\C-v" [escape])
- "[]line 1\nline 2\nline 3\n")))
-
-(ert-deftest evil-test-insert-vcount ()
- "Test `evil-insert' with vertical repeating"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-
-;; Below the empty line."
- (define-key evil-normal-state-local-map "i"
- #'(lambda (count)
- (interactive "p")
- (evil-insert count 5)))
- ("2iABC" [escape])
- "\
-;; ABCAB[C]This buffer is for notes you don't want to save.
-;; ABCABCIf you want to create a file, visit that file with C-x C-f,
-;; ABCABCthen enter the text in that file's own buffer.
- ABCABC
-;; ABCABCBelow the empty line."))
-
-(ert-deftest evil-test-append-with-count ()
- "Test `evil-append' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes"
- ("2aevil rulz " [escape])
- ";; Tevil rulz evil rulz[ ]his buffer is for notes"))
-
-(ert-deftest evil-test-repeat-append ()
- "Test repeating of `evil-append'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("aABC" [escape])
- ";AB[C]; This buffer is for notes"
- ("..")
- ";ABCABCAB[C]; This buffer is for notes"))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("2aABC" [escape])
- ";ABCAB[C]; This buffer is for notes"
- ("..")
- ";ABCABCABCABCABCAB[C]; This buffer is for notes"))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("aABC" [escape])
- ";AB[C]; This buffer is for notes"
- ("11.")
- ";ABCABCABCABCABCABCABCABCABCABCABCAB[C]; This buffer is for notes"))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- "[;]; This buffer is for notes"
- ("10aABC" [escape])
- ";ABCABCABCABCABCABCABCABCABCAB[C]; This buffer is for notes"
- ("11.")
- ";ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCAB[C]; \
-This buffer is for notes")))
-
-(ert-deftest evil-test-append-vcount ()
- "Test `evil-append' with vertical repeating"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-
-;; Below the empty line."
- (define-key evil-normal-state-local-map "a"
- #'(lambda (count)
- (interactive "p")
- (evil-append count 5)))
- ("2aABC" [escape])
- "\
-;; TABCAB[C]his buffer is for notes you don't want to save.
-;; IABCABCf you want to create a file, visit that file with C-x C-f,
-;; tABCABChen enter the text in that file's own buffer.
- ABCABC
-;; BABCABCelow the empty line."))
-
-(ert-deftest evil-test-open-above-with-count ()
- "Test `evil-open-above' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("2Oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."))
-
-(ert-deftest evil-test-repeat-open-above ()
- "Test repeating of `evil-open-above'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save."
- ("Oevil\nrulz" [escape])
- "evil\nrul[z]
-;; This buffer is for notes you don't want to save."
- ("..")
- "evil\nevil\nevil\nrul[z]\nrulz\nrulz
-;; This buffer is for notes you don't want to save."))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save."
- ("2Oevil\nrulz" [escape])
- "evil\nrulz\nevil\nrul[z]
-;; This buffer is for notes you don't want to save."
- ("..")
- "evil\nrulz\nevil\nevil\nrulz\nevil\nevil\nrulz\nevil\nrul[z]\nrulz\nrulz
-;; This buffer is for notes you don't want to save."))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save."
- ("Oevil\nrulz" [escape])
- "evil\nrul[z]\n;; This buffer is for notes you don't want to save."
- ("2.")
- "evil\nevil\nrulz\nevil\nrul[z]\nrulz
-;; This buffer is for notes you don't want to save."))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save."
- ("2Oevil\nrulz" [escape])
- "evil\nrulz\nevil\nrul[z]
-;; This buffer is for notes you don't want to save."
- ("3.")
- "evil\nrulz\nevil\nevil\nrulz\nevil\nrulz\nevil\nrul[z]\nrulz
-;; This buffer is for notes you don't want to save.")))
-
-(ert-deftest evil-test-open-below-with-count ()
- "Test insertion of `evil-open-below' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."))
-
-(ert-deftest evil-test-repeat-open-below ()
- "Test repeating `evil-open-below'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrul[z]\n;; and for Lisp evaluation."
- ("..")
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."
- ("..")
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrulz\nevil\nrulz\nevil\nrulz\nevil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrul[z]\n;; and for Lisp evaluation."
- ("2.")
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2oevil\nrulz" [escape])
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation."
- ("3.")
- ";; This buffer is for notes you don't want to save,
-evil\nrulz\nevil\nrulz\nevil\nrulz\nevil\nrulz\nevil\nrul[z]
-;; and for Lisp evaluation.")))
-
-(ert-deftest evil-test-insert-line-with-count ()
- "Test `evil-insert-line' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes"
- ("2Ievil rulz " [escape])
- "evil rulz evil rulz[ ];; This buffer is for notes"))
-
-(ert-deftest evil-test-repeat-insert-line ()
- "Test repeating of `evil-insert-line'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- ";; This buffer is for note[s]"
- ("IABC" [escape])
- "AB[C];; This buffer is for notes"
- ("..")
- "AB[C]ABCABC;; This buffer is for notes"))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- ";; This buffer is for note[s]"
- ("2IABC" [escape])
- "ABCAB[C];; This buffer is for notes"
- ("..")
- "ABCAB[C]ABCABCABCABC;; This buffer is for notes"))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- ";; This buffer is for note[s]"
- ("IABC" [escape])
- "AB[C];; This buffer is for notes"
- ("11.")
- "ABCABCABCABCABCABCABCABCABCABCAB[C]ABC;; This buffer is for notes"))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- ";; This buffer is for note[s]"
- ("10IABC" [escape])
- "ABCABCABCABCABCABCABCABCABCAB[C];; This buffer is for notes"
- ("11.")
- "ABCABCABCABCABCABCABCABCABCABCAB[C]ABCABCABCABCABCABCABCABCABCABC;;
This buffer is for notes")))
-
-(ert-deftest evil-test-insert-line-vcount ()
- "Test `evil-insert-line' with vertical repeating"
- :tags '(evil repeat)
- (evil-test-buffer
- "int[ ]main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- (define-key evil-normal-state-local-map "I"
- #'(lambda (count)
- (interactive "p")
- (evil-insert-line count 4)))
- ("2IABC" [escape])
- "ABCABCint main(int argc, char** argv)
-ABCABC{
- ABCABCprintf(\"Hello world\\n\");
- ABCABCreturn EXIT_SUCCESS;
-}"))
-
-(ert-deftest evil-test-append-line-with-count ()
- "Test `evil-append-line' with repeat count"
- :tags '(evil repeat)
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("2Aevil rulz " [escape])
- ";; This buffer is for notes.evil rulz evil rulz[ ]"))
-
-(ert-deftest evil-test-repeat-append-line ()
- "Test repeating of `evil-append-line'"
- :tags '(evil repeat)
- (ert-info ("Repeat insert")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("AABC" [escape])
- ";; This buffer is for notes.AB[C]"
- ("..")
- ";; This buffer is for notes.ABCABCAB[C]"))
- (ert-info ("Repeat insert with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("2AABC" [escape])
- ";; This buffer is for notes.ABCAB[C]"
- ("..")
- ";; This buffer is for notes.ABCABCABCABCABCAB[C]"))
- (ert-info ("Repeat insert with repeat count")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("AABC" [escape])
- ";; This buffer is for notes.ABC"
- ("11.")
- ";; This buffer is for notes.ABCABCABCABCABCABCABCABCABCABCABCAB[C]"))
- (ert-info ("Repeat insert with count with repeat with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("10AABC" [escape])
- ";; This buffer is for notes.ABCABCABCABCABCABCABCABCABCAB[C]"
- ("11.")
- ";; This buffer is for
notes.ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCAB[C]")))
-
-(ert-deftest evil-test-append-line-vcount ()
- "Test `evil-append-line' with vertical repeating"
- :tags '(evil repeat)
- (evil-test-buffer
- "int[ ]main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- (define-key evil-normal-state-local-map "A"
- #'(lambda (count)
- (interactive "p")
- (evil-append-line count 4)))
- ("2AABC" [escape])
- "int main(int argc, char** argv)ABCAB[C]
-{ABCABC
- printf(\"Hello world\\n\");ABCABC
- return EXIT_SUCCESS;ABCABC
-}"))
-
-(ert-deftest evil-test-repeat-by-change ()
- "Test repeating by tracking changes for completion commands"
- :tags '(evil repeat)
- (let ((line-move-visual nil)
- (change (evil-define-command nil ()
- :repeat change
- (interactive)
- (delete-char 5)
- (insert "BEGIN\n")
- (save-excursion
- (insert "\nEND\n")))))
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (define-key evil-insert-state-local-map (kbd "C-c C-p") change)
- ("iABC " (kbd "C-c C-p") "BODY" [escape])
- ";; ABC BEGIN
-BOD[Y]
-END
-buffer is for notes."
- (".")
- ";; ABC BEGIN
-BODABC BEGIN
-BOD[Y]
-END
-
-buffer is for notes.")))
-
-(ert-deftest evil-test-repeat-kill-buffer ()
- "Test safe-guard preventing buffers from being deleted
-when repeating a command"
- :tags '(evil repeat)
- (ert-info ("Test killing works for direct calls \
-to `evil-execute-repeat-info'")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- (ring-insert evil-repeat-ring '((kill-buffer nil)))
- (evil-execute-repeat-info (ring-ref evil-repeat-ring 0))
- (should-not (looking-at ";; This"))))
- (ert-info ("Verify an error is raised when using \
-the `evil-repeat' command")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- (ring-insert evil-repeat-ring '((kill-buffer nil)))
- (evil-execute-repeat-info (ring-ref evil-repeat-ring 0))
- (should-error (call-interactively #'evil-repeat)))))
-
-(ert-deftest evil-test-repeat-pop ()
- "Test `repeat-pop'."
- :tags '(evil repeat)
- (ert-info ("Test repeat-pop")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- ("iABC" [escape] "aXYZ" [escape])
- ";; ABCXY[Z]This buffer is for notes."
- (".")
- ";; ABCXYZXY[Z]This buffer is for notes."))
- (ert-info ("Test repeat-pop")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- ("iABC" [escape] "aXYZ" [escape])
- ";; ABCXY[Z]This buffer is for notes."
- ("." (kbd "C-."))
- ";; ABCXYAB[C]ZThis buffer is for notes."))
- (ert-info ("Test repeat-pop-next")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- ("iABC" [escape] "aXYZ" [escape])
- ";; ABCXY[Z]This buffer is for notes."
- ("." (kbd "C-.") (kbd "M-."))
- ";; ABCXYZXY[Z]This buffer is for notes."))
- (ert-info ("Test repeat-pop after non-change")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- ("iABC" [escape] "a" [escape] "aXYZ" [escape])
- ";; ABCXY[Z]This buffer is for notes."
- ("." (kbd "C-.") (kbd "C-."))
- ";; ABCXYAB[C]ZThis buffer is for notes.")))
-
-(ert-deftest evil-test-ESC-repeat-normal-state ()
- "Test if ESC is not been recorded in normal state."
- :tags '(evil repeat)
- (ert-info ("Test normal ESC")
- (evil-test-buffer
- ";;[ ]This buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- (should (= (ring-length evil-repeat-ring) 0))
- ("aABC" [escape])
- ";; AB[C]This buffer is for notes."
- (should (= (ring-length evil-repeat-ring) 1))
- (".")
- ";; ABCAB[C]This buffer is for notes."
- ([escape])
- (should (= (ring-length evil-repeat-ring) 1))
- (".")
- ";; ABCABCAB[C]This buffer is for notes.")))
-
-(ert-deftest evil-test-abort-operator-repeat ()
- "Test if ESC in operator-state cancels recording of repeation."
- :tags '(evil repeat)
- (let ((inhibit-quit t))
- (ert-info ("Test ESC")
- (evil-test-buffer
- ";;[ ]This buffer is for notes."
- (setq evil-repeat-ring (make-ring 10))
- (should (= (ring-length evil-repeat-ring) 0))
- ("aABC" [escape])
- ";; AB[C]This buffer is for notes."
- (should (= (ring-length evil-repeat-ring) 1))
- (".")
- ";; ABCAB[C]This buffer is for notes."
- ("d" [escape])
- (should (= (ring-length evil-repeat-ring) 1))
- (".")
- ";; ABCABCAB[C]This buffer is for notes."))))
-
-(ert-deftest evil-test-repeat-visual-char ()
- "Test repeat of character visual mode command."
- :tags '(evil repeat)
- (ert-info ("Test repeat on same line")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("v3lcABC" [escape])
- ";; AB[C] buffer is for notes."
- ("ww.")
- ";; ABC buffer AB[C]or notes."))
- (ert-info ("Test repeat on several lines")
- (evil-test-buffer
- ";; This [b]uffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ("vj^eerX")
- ";; This XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXX[X] you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ("2gg^3w.")
- ";; This XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXXX you want XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-XXXX[X]en enter the text in that file's own buffer.
-")))
-
-(ert-deftest evil-test-repeat-visual-line ()
- "Test repeat of linewise visual mode command."
- :tags '(evil repeat)
- (ert-info ("Test repeat on several lines")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter th[e] text in that file's own buffer.
-
-;; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ("VkcNew Text" [escape])
- ";; This buffer is for notes you don't want to save.
-New Tex[t]
-
-;; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ("jj.")
- ";; This buffer is for notes you don't want to save.
-New Text
-
-New Tex[t]
-;; then enter the text in that file's own buffer.
-")))
-
-(ert-deftest evil-test-repeat-visual-block ()
- "Test repeat of block visual mode command."
- :tags '(evil repeat)
- (ert-info ("Test repeat on several lines")
- (evil-test-buffer
- ";; This [b]uffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-;; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ((kbd "C-v") "3j2lrQ")
- ";; This [Q]QQfer is for notes you don't want to save.
-;; If yoQQQant to create a file, visit that file with C-x C-f,
-;; then QQQer the text in that file's own buffer.
-;; This QQQfer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer.
-"
- ("2j3w.")
- ";; This QQQfer is for notes you don't want to save.
-;; If yoQQQant to create a file, visit that file with C-x C-f,
-;; then QQQer the text [Q]QQthat file's own buffer.
-;; This QQQfer is for nQQQs you don't want to save.
-;; If you want to creatQQQ file, visit that file with C-x C-f,
-;; then enter the text QQQthat file's own buffer.
-")))
-
-(ert-deftest evil-visual-block-append ()
- "Test appending in visual block."
- :tags '(evil visual insert)
- (ert-info ("Simple append")
- (evil-test-buffer
- "l[i]ne 1\nline 2\nline 3\n"
- ((kbd "C-v") "jjllAXXX" [escape])
- "lineXX[X] 1\nlineXXX 2\nlineXXX 3\n"))
- (ert-info ("Append after empty lines")
- (evil-test-buffer
- "line 1l[i]ne 1\nline 2\nline 3line 3\n"
- (setq indent-tabs-mode nil)
- ((kbd "C-v") "jjllAXXX" [escape])
- "line 1lineXX[X] 1\nline 2 XXX\nline 3lineXXX 3\n"))
- (ert-info ("Append after empty first line")
- (evil-test-buffer
- "l[i]ne 1line 1\nline 2\nline 3line 3line 3\n"
- (setq indent-tabs-mode nil)
- ((kbd "C-v") "jj3feAXXX" [escape])
- "line 1line 1 XX[X]\nline 2 XXX\nline 3line 3lineXXX 3\n"))
- (ert-info ("Append after end of lines")
- (evil-test-buffer
- "line 1l[i]ne 1line 1\nline 2\nline 3line 3\n"
- (setq indent-tabs-mode nil)
- ((kbd "C-v") "jj$AXXX" [escape])
- "line 1line 1line 1XX[X]\nline 2XXX\nline 3line 3XXX\n")))
-
-(ert-deftest evil-test-repeat-digraph ()
- "Test repeat of insertion of a digraph."
- :tags '(evil digraph repeat)
- (evil-test-buffer
- "Line with ['] several apostrophes ', yeah."
- ("s" (kbd "C-k") "'9" [escape])
- "Line with [’] several apostrophes ', yeah."
- ("f'.")
- "Line with ’ several apostrophes [’], yeah."))
-
-;;; Operators
-
-(ert-deftest evil-test-keypress-parser ()
- "Test `evil-keypress-parser'"
- :tags '(evil operator)
- (evil-test-buffer
- :state operator
- (ert-info ("Read from the keyboard unless INPUT is given")
- (evil-test-buffer
- :state operator
- (let ((unread-command-events '(?d)))
- (should (equal (evil-keypress-parser)
- '(evil-delete nil)))
- (should (equal (evil-keypress-parser '(?d))
- '(evil-delete nil))))))
- (ert-info ("Read remainder from the keyboard if INPUT is incomplete")
- (let ((unread-command-events '(?d)))
- (should (equal (evil-keypress-parser '(?2))
- '(evil-delete 2)))))
- (ert-info ("Handle counts not starting with zero")
- (should (equal (evil-keypress-parser '(?2 ?d))
- '(evil-delete 2)))
- (should (equal (evil-keypress-parser '(?2 ?0 ?d))
- '(evil-delete 20)))
- (should (equal (evil-keypress-parser '(?2 ?0 ?2 ?d))
- '(evil-delete 202)))
- (should (equal (evil-keypress-parser '(?4 ?0 ?4 ?g ??))
- '(evil-rot13 404))))
- (ert-info ("Treat 0 as a motion")
- (should (equal
- (evil-keypress-parser '(?0))
- '(evil-digit-argument-or-evil-beginning-of-line nil))))
- (ert-info ("Handle keyboard macros")
- (evil-test-buffer
- (define-key evil-motion-state-local-map (kbd "W") (kbd "w"))
- (should (equal (evil-keypress-parser '(?W))
- '(evil-forward-word-begin nil)))))))
-
-(ert-deftest evil-test-invert-char ()
- "Test `evil-invert-char'"
- :tags '(evil operator)
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("~")
- ";; t[h]is buffer is for notes.")
- (evil-test-buffer
- ";; <[T]his> buffer is for notes."
- ("~")
- ";; [t]HIS buffer is for notes.")
- (evil-test-buffer
- :visual block
- ";; <[T]his buffer is for notes,
-;; and >for Lisp evaluation."
- ("~")
- ";; [t]HIS buffer is for notes,
-;; AND for Lisp evaluation."))
-
-(ert-deftest evil-test-rot13 ()
- "Test `evil-rot13'"
- :tags '(evil operator)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("g?" [M-right])
- ";; [G]uvf buffer is for notes you don't want to save."))
-
-(ert-deftest evil-test-rot13-with-count ()
- "Test `evil-rot13' with count argument"
- :tags '(evil operator)
- (ert-info ("Count before operator")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("2g?" [M-right])
- ";; [G]uvf ohssre is for notes you don't want to save."))
- (ert-info ("Count before motion")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("g?2" [M-right])
- ";; [G]uvf ohssre is for notes you don't want to save."))
- (ert-info ("Count before operator and motion")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("3g?2" [M-right])
- ";; [G]uvf ohssre vf sbe abgrf lbh don't want to save."))
- (ert-info ("Count exceeding buffer boundaries")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("g?200" [right])
- ";; [G]uvf ohssre vf sbe abgrf lbh qba'g jnag gb fnir.")))
-
-(ert-deftest evil-test-rot13-repeat ()
- "Test repeating of `evil-rot13'"
- :tags '(evil operator)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("g?" [M-right] [M-right])
- ";; Guvf[ ]buffer is for notes you don't want to save."
- (".")
- ";; Guvf[ ]ohssre is for notes you don't want to save."))
-
-(ert-deftest evil-test-rot13-repeat-with-count ()
- "Test repeating of `evil-rot13' with new count"
- :tags '(evil operator)
- (ert-info ("Count before operator")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("2g?" [M-right])
- ";; [G]uvf ohssre is for notes you don't want to save."
- ("3.")
- ";; [T]his buffer vf for notes you don't want to save."))
- (ert-info ("Count before motion")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("g?2" [M-right])
- ";; [G]uvf ohssre is for notes you don't want to save."
- ("3.")
- ";; [T]his buffer vf for notes you don't want to save."))
- (ert-info ("Count before operator and motion")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("3g?2" [M-right])
- ";; [G]uvf ohssre vf sbe abgrf lbh don't want to save."
- ("4.")
- ";; [T]his buffer is for abgrf lbh don't want to save.")))
-
-(ert-deftest evil-test-operator-delete ()
- "Test deleting text"
- :tags '(evil operator)
- (ert-info ("Delete characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("dl")
- ";; [h]is buffer is for notes."
- ("d1l")
- ";; [i]s buffer is for notes."
- ("1dl")
- ";; [s] buffer is for notes."
- ("1d1l")
- ";; [ ]buffer is for notes."
- ("d2l")
- ";; [u]ffer is for notes."
- ("2dl")
- ";; [f]er is for notes."
- ("d4l")
- ";; [i]s for notes."
- ("4dl")
- ";; [o]r notes."
- ("2d2l")
- ";; [o]tes."))
- (ert-info ("Delete current line")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("dd")
- "[;]; and for Lisp evaluation.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("d1d")
- "[;]; and for Lisp evaluation.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("1dd")
- "[;]; and for Lisp evaluation.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("1d1d")
- "[;]; and for Lisp evaluation."))
- (ert-info ("Delete two lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("d2d")
- "[;]; then enter the text in that file's own buffer.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2dd")
- "[;]; then enter the text in that file's own buffer.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("dj")
- "[;]; then enter the text in that file's own buffer.")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; [I]f you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("dk")
- "[;]; then enter the text in that file's own buffer.")))
-
-(evil-define-motion evil-test-square-motion (count)
- "Test motion for selecting a square."
- :type block
- (let ((column (current-column)))
- (forward-line (1- count))
- (move-to-column (+ column count -1))))
-
-(ert-deftest evil-test-yank ()
- "Test `evil-yank'"
- :tags '(evil operator yank)
- (ert-info ("Yank characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("y2e")
- (should (string= (current-kill 0) "This buffer"))))
- (ert-info ("Yank lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("yj")
- (should (string= (current-kill 0)
- (buffer-substring (point-min)
- (1+ (line-end-position 2)))))
- (should (eq (car-safe (get-text-property 0 'yank-handler
- (current-kill 0)))
- 'evil-yank-line-handler)))
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-\[;]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("y5j")
- (should
- (string= (current-kill 0)
- (concat (buffer-substring (line-beginning-position 1)
- (point-max))
- "\n")))
- (should (eq (car-safe (get-text-property 0 'yank-handler
- (current-kill 0)))
- 'evil-yank-line-handler))))
- (ert-info ("Yank rectangle")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y3s")
- (should (string= (current-kill 0) "Thi\nIf \nthe"))
- (should (eq (car-safe (get-text-property 0 'yank-handler
- (current-kill 0)))
- 'evil-yank-block-handler))))
- (ert-info (":yank, then paste")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":yank" [return] "p")
- "a\nb\nb\nc\nd\n"))
- (ert-info (":yank with COUNT")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":yank 2" [return] "p")
- "a\nb\nb\nc\nc\nd\n"))
- (ert-info (":yank with COUNT in visual state")
- (evil-test-buffer
- "a\n<b\nc>\nd\ne\nf\n"
- (":yank 3" [return] "p")
- "a\nb\nc\nd\ne\nc\nd\ne\nf\n"))
- (ert-info (":yank with REGISTER")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":yank r") ;; yank into the 'r' register
- "a\nb\nc\nd\n"
- ;; check the 'r' register contains the yanked text
- (should (string= (substring-no-properties (evil-get-register ?r))
"b\n"))))
- (ert-info (":yank with REGISTER and COUNT")
- (evil-test-buffer
- "a\n[b]\nc\nd\ne\nf\n"
- (":yank r 3")
- "a\nb\nc\nd\ne\nf\n"
- (should (string= (substring-no-properties (evil-get-register ?r))
"b\nc\nd\n")))))
-
-(ert-deftest evil-test-delete ()
- "Test `evil-delete'"
- :tags '(evil operator delete)
- (ert-info ("Delete characters")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save[.]"
- ("x")
- ";; This buffer is for notes you don't want to sav[e]"
- (goto-char 4)
- ";; [T]his buffer is for notes you don't want to save"
- ("d2e")
- ";; [ ]is for notes you don't want to save"
- (should (string= (current-kill 0) "This buffer"))
- ("P")
- ";; This buffe[r] is for notes you don't want to save"))
- (ert-info ("Delete lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2dd")
- "[;]; then enter the text in that file's own buffer."
- ("P")
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Delete last line")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; [I]f you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2dd")
- "[;]; This buffer is for notes you don't want to save."))
- (ert-info ("Delete last empty line")
- (evil-test-buffer
- "line 1\nline 2\n\n[]"
- ("dd")
- "line 1\nline 2\n[]"))
- (ert-info ("Delete rectangle")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("d3s")
- "[T]his buffer is for notes you don't want to save.
-If you want to create a file, visit that file with C-x C-f,
-then enter the text in that file's own buffer."))
- (ert-info (":delete")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":delete")
- "a\nc\nd\n"))
- (ert-info (":delete with COUNT")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":delete 2")
- "a\nd\n"))
- (ert-info (":delete with COUNT in visual state")
- (evil-test-buffer
- "a\n<b\nc>\nd\ne\nf\n"
- (":delete 3")
- "a\nb\nf\n"))
- (ert-info (":delete with REGISTER")
- (evil-test-buffer
- "a\n[b]\nc\nd\n"
- (":delete r") ;; delete into the 'r' register
- "a\nc\nd\n"
- ;; check the 'r' register contains the deleted text
- (should (string= (substring-no-properties (evil-get-register ?r))
"b\n"))))
- (ert-info (":delete with REGISTER and COUNT")
- (evil-test-buffer
- "a\n[b]\nc\nd\ne\nf\n"
- (":delete r 3")
- "a\ne\nf\n"
- (should (string= (substring-no-properties (evil-get-register ?r))
"b\nc\nd\n")))))
-
-(ert-deftest evil-test-delete-line ()
- "Test `evil-delete-line'"
- :tags '(evil operator)
- (ert-info ("Delete to end of line")
- (evil-test-buffer
- ";; This buffer is for notes[ ]you don't want to save."
- ("D")
- ";; This buffer is for note[s]"))
- (ert-info ("Act linewise on character selection")
- (evil-test-buffer
- ";; This <buffe[r]> is for notes,
-and for Lisp evaluation."
- ("D")
- "[a]nd for Lisp evaluation."))
- (ert-info ("Act on each line of block selection")
- (evil-test-buffer
- :visual block
- ";; This buffer is for <notes,
-;; and for Lisp evaluatio[n]>."
- ("D")
- ";; This buffer is for[ ]
-;; and for Lisp evalua"))
- (ert-info ("Yank full block with block selection")
- (evil-test-buffer
- :visual block
- "line1 l<ine1 line1 line1\nline2 line2\nline3 lin>e3 line3\n"
- ("D")
- "line1 [l]\nline2 l\nline3 l\n"
- ("0P")
- "ine1 line1 line1line1 l
-ine2 line2 l
-ine3 line3 line3 l\n")))
-
-(ert-deftest evil-test-delete-folded ()
- "Test `evil-delete' on folded lines."
- :tags '(evil operator)
- (ert-info ("Delete folded lines")
- (evil-test-buffer
- "[l]ine1\n\n(let ()\n var)\n\n(let ()\n var2)\n"
- (emacs-lisp-mode)
- (hs-minor-mode 1)
- ("zm2jdd")
- "line1\n\n[\n](let ()\n var2)\n"))
- (ert-info ("Delete folded lines with count")
- (evil-test-buffer
- "[l]ine1\n\n(let ()\n var)\n\n(let ()\n var2)\n\nlast line\n"
- (emacs-lisp-mode)
- (hs-minor-mode 1)
- ("zm2j3dd")
- "line1\n\n[\n]last line\n")))
-
-(ert-deftest evil-test-delete-backward-word ()
- "Test `evil-delete-backward-word' in insert state."
- :tags '(evil)
- (let ((evil-backspace-join-lines t))
- (evil-test-buffer
- "abc def\n ghi j[k]l\n"
- ("i" (kbd "C-w"))
- "abc def\n ghi [k]l\n"
- ((kbd "C-w"))
- "abc def\n [k]l\n"
- ((kbd "C-w"))
- "abc def\n[k]l\n"
- ((kbd "C-w"))
- "abc def[k]l\n"))
- (let (evil-backspace-join-lines)
- (evil-test-buffer
- "abc def\n[k]l\n"
- (should-error (execute-kbd-macro (concat "i" (kbd "C-w"))))
- "abc def\n[k]l\n")))
-
-(ert-deftest evil-test-change ()
- "Test `evil-change'"
- :tags '(evil operator)
- (ert-info ("Change characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("c2eABC" [escape])
- ";; AB[C] is for notes you don't want to save."
- (should (string= (current-kill 0) "This buffer"))
- ("p")
- ";; ABCThis buffe[r] is for notes you don't want to save."))
- (ert-info ("Change lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2ccABCLINE\nDEFLINE" [escape])
- "ABCLINE
-DEFLIN[E]
-;; then enter the text in that file's own buffer."
- ("p")
- "ABCLINE
-DEFLINE
-\[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Change last line")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; [I]f you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2ccABC" [escape])
- ";; This buffer is for notes you don't want to save.
-AB[C]"))
- (ert-info ("Change rectangle")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("c3sABC" [escape])
- "AB[C]This buffer is for notes you don't want to save.
-ABCIf you want to create a file, visit that file with C-x C-f,
-ABCthen enter the text in that file's own buffer.")))
-
-(ert-deftest evil-test-change-word ()
- "Test changing words"
- :tags '(evil operator)
- (ert-info ("Non-word")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("cwABC" [escape])
- "AB[C] This buffer is for notes."))
- (ert-info ("Word")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("cwABC" [escape])
- ";; AB[C] buffer is for notes."))
- (ert-info ("Single character")
- (evil-test-buffer
- "[;] This buffer is for notes."
- ("cwABC" [escape])
- "AB[C] This buffer is for notes."))
- (ert-info ("Whitespace")
- (evil-test-buffer
- "This[ ]is a test\n"
- ("cwABC" [escape])
- "ThisAB[C]is a test\n")))
-
-(ert-deftest evil-test-join ()
- "Test `evil-join'"
- :tags '(evil join operator)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f."
- ("J")
- ";; This buffer is for notes you don't want to save.[ ]\
-;; If you want to create a file, visit that file with C-x C-f."))
- (ert-info ("Visual")
- (evil-test-buffer
- :visual line
- "<;; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f.>"
- ("J")
- ";; This buffer is for notes you don't want to save.[ ]\
-;; If you want to create a file, visit that file with C-x C-f."))
- (ert-info ("Join with count")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":join 3")
- "line 1 line 2 line 3\nline 4"))
- (ert-info ("Join with bang and count")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":join! 3")
- "line 1line 2line 3\nline 4"))
- (ert-info ("Join with bang and count, exceeding end-of-buffer")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":join! 10")
- "line 1line 2line 3line 4"))
- (ert-info ("Join with count 1 should be the same as without count")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":join 1")
- "line 1 line 2\nline 3\nline 4"))
- (ert-info ("Join with count 2 should be the same as with count 1")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":join 2")
- "line 1 line 2\nline 3\nline 4"))
- (ert-info ("Join with count and single line range")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":2join 3")
- "line 1\nline 2 line 3 line 4"))
- (ert-info ("Join with count and range")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":1,2join 3")
- "line 1\nline 2 line 3 line 4"))
- (ert-info ("Join with count, range and bang")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":1,2join! 3")
- "line 1\nline 2line 3line 4"))
- (ert-info ("Join with range")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4"
- (":1,3join")
- "line 1 line 2 line 3\nline 4"))
- )
-
-(ert-deftest evil-test-substitute ()
- "Test `evil-substitute'"
- :tags '(evil operator)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("5sABC" [escape])
- ";; AB[C]buffer is for notes."))
- (ert-info ("On empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("5sABC" [escape])
- "Above some line
-AB[C]
-Below some empty line")))
-
-(ert-deftest evil-test-shift ()
- "Test `evil-shift-right' and `evil-shift-left'."
- :tags '(evil operator)
- (let ((evil-shift-width 4)
- indent-tabs-mode)
- (ert-info ("Shift linewise")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\n"
- ("Vj>")
- " [l]ine 1\n line 2\nline 3\n"))
- (ert-info ("Shift char selection on whole line")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\n"
- ("v$>")
- " [l]ine 1\nline 2\nline 3\n"))
- (ert-info ("Shift visual with count")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\n"
- ("Vj3>")
- " [l]ine 1\n line 2\nline 3\n"
- ("Vj2<")
- " [l]ine 1\n line 2\nline 3\n"))
- (ert-info ("Shift in insert state")
- (evil-test-buffer
- "line 1\nl[i]ne 2\nline 3\n"
- ("i\C-t\C-t")
- "line 1\n l[i]ne 2\nline 3\n"
- ("\C-d")
- "line 1\n l[i]ne 2\nline 3\n"))))
-
-;;; Paste
-
-(ert-deftest evil-test-paste-before ()
- "Test `evil-paste-before'"
- :tags '(evil paste)
- (ert-info ("Paste characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2ej0")
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("P")
- ";; This buffer is for notes you don't want to save,
-This buffe[r];; and for Lisp evaluation."))
- (ert-info ("Paste characters with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2ej0")
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("3P")
- ";; This buffer is for notes you don't want to save,
-This bufferThis bufferThis buffe[r];; and for Lisp evaluation."))
- (ert-info ("Paste characters at end-of-buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2eG$")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation[.]"
- ("2P")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluationThis bufferThis buffe[r]."))
- (ert-info ("Paste lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yyP")
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."))
- (ert-info ("Paste lines with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yy2P")
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."))
- (ert-info ("Paste lines at end-of-buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yyG$")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation[.]"
- ("2P")
- ";; This buffer is for notes you don't want to save,
-\[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; and for Lisp evaluation."))
- (ert-info ("Paste block")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ysP")
- "[;]; ;; This buffer is for notes you don't want to save.
-;; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; then enter the text in that file's own buffer."))
- (ert-info ("Paste block with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys2P")
- "[;]; ;; ;; This buffer is for notes you don't want to save.
-;; ;; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; ;; then enter the text in that file's own buffer."))
- (ert-info ("Paste block with empty line")
- (evil-test-buffer
- "[;]; Above some line
-
-;; Below some empty line"
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys2P")
- "[;]; ;; ;; Above some line
- \n\
-;; ;; ;; Below some empty line"))
- (ert-info ("Paste block crossing end of buffer")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ysj")
- ";; This buffer is for notes you don't want to save.
-\[;]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("P")
- ";; This buffer is for notes you don't want to save.
-\[;]; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; then enter the text in that file's own buffer.
-;;"))
- (ert-info ("Paste block at end-of-line")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys$")
- ";; This buffer is for notes you don't want to save[.]
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("p")
- ";; This buffer is for notes you don't want to save.[;];
-;; If you want to create a file, visit that file wi;; th C-x C-f,
-;; then enter the text in that file's own buffer. ;;")))
-
-(ert-deftest evil-test-paste-after ()
- "Test `evil-paste-after'"
- :tags '(evil paste)
- (ert-info ("Paste characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2ej0")
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("p")
- ";; This buffer is for notes you don't want to save,
-;This buffe[r]; and for Lisp evaluation."))
- (ert-info ("Paste characters with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2ej0")
- ";; This buffer is for notes you don't want to save,
-\[;]; and for Lisp evaluation."
- ("3p")
- ";; This buffer is for notes you don't want to save,
-;This bufferThis bufferThis buffe[r]; and for Lisp evaluation."))
- (ert-info ("Paste characters at end-of-buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("y2eG$")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation[.]"
- ("2p")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.This bufferThis buffe[r]"))
- (ert-info ("Paste lines")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yyp")
- ";; This buffer is for notes you don't want to save,
-\[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; and for Lisp evaluation."))
- (ert-info ("Paste lines with count")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yy2p")
- ";; This buffer is for notes you don't want to save,
-\[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; and for Lisp evaluation."))
- (ert-info ("Paste lines at end-of-buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("2yyG$")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation[.]"
- ("2p")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-\[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation."))
- (ert-info ("Paste block")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ysp")
- ";[;]; ; This buffer is for notes you don't want to save.
-;;; ; If you want to create a file, visit that file with C-x C-f,
-;;; ; then enter the text in that file's own buffer."))
- (ert-info ("Paste block with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys2p")
- ";[;]; ;; ; This buffer is for notes you don't want to save.
-;;; ;; ; If you want to create a file, visit that file with C-x C-f,
-;;; ;; ; then enter the text in that file's own buffer."))
- (ert-info ("Paste block with empty line")
- (evil-test-buffer
- "[;]; Above some line
-
-;; Below some empty line"
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys2p")
- ";;; ;; ; Above some line
-
-;;; ;; ; Below some empty line"))
- (ert-info ("Paste block crossing end of buffer")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ysj")
- ";; This buffer is for notes you don't want to save.
-\[;]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("p")
- ";; This buffer is for notes you don't want to save.
-;;; ; If you want to create a file, visit that file with C-x C-f,
-;;; ; then enter the text in that file's own buffer.
- ;;"))
- (ert-info ("Paste block at end-of-line")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("3ys$")
- ";; This buffer is for notes you don't want to save[.]
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("p")
- ";; This buffer is for notes you don't want to save.;;
-;; If you want to create a file, visit that file wi;; th C-x C-f,
-;; then enter the text in that file's own buffer. ;;"))
- (ert-info ("Paste preserves preceding text properties")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (put-text-property (point) (line-end-position) 'font-lock-face 'warning)
- ("yyp")
- ";; This buffer is for notes you don't want to save.
-[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (should (equal (get-text-property (point-min) 'font-lock-face) 'warning)))))
-
-(ert-deftest evil-test-paste-pop-before ()
- "Test `evil-paste-pop' after `evil-paste-before'"
- :tags '(evil paste)
- (ert-info ("Paste")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sj")
- ";; This buffer is for notes you don't want to save.
-\[;]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("P")
- ";; This buffer is for notes you don't want to save.
-\[;]; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; then enter the text in that file's own buffer.
-;;"))
- (ert-info ("Single pop")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP\C-p")
- ";; This buffer is for notes you don't want to save.
-\[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Two pops")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP\C-p\C-p")
- ";; This buffer is for notes you don't want to save.
-;; Thi[s];; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Pop with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP2\C-p")
- ";; This buffer is for notes you don't want to save.
-;; Thi[s];; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Single pop-next")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP2\C-p\C-n")
- ";; This buffer is for notes you don't want to save.
-\[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Pop-next with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP\C-p\C-p2\C-n")
- ";; This buffer is for notes you don't want to save.
-\[;]; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; then enter the text in that file's own buffer.
-;;")))
-
-(ert-deftest evil-test-paste-pop-after ()
- "Test `evil-paste-pop' after `evil-paste-after'"
- :tags '(evil paste)
- (ert-info ("Paste")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sj")
- ";; This buffer is for notes you don't want to save.
-\[;]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("p")
- ";; This buffer is for notes you don't want to save.
-;[;]; ; If you want to create a file, visit that file with C-x C-f,
-;;; ; then enter the text in that file's own buffer.
- ;;"))
- (ert-info ("Single pop")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjp\C-p")
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-\[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Two pops")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjp\C-p\C-p")
- ";; This buffer is for notes you don't want to save.
-;;; Thi[s]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Pop with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjp2\C-p")
- ";; This buffer is for notes you don't want to save.
-;;; Thi[s]; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Single pop-next")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjp2\C-p\C-n")
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-\[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Pop-next with count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjp\C-p\C-p2\C-n")
- ";; This buffer is for notes you don't want to save.
-;[;]; ; If you want to create a file, visit that file with C-x C-f,
-;;; ; then enter the text in that file's own buffer.
- ;;")))
-
-(ert-deftest evil-test-paste-pop-without-undo ()
- "Test `evil-paste-pop' with undo disabled"
- :tags '(evil paste)
- (ert-info ("Pop-next with count without undo")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (setq buffer-undo-list t)
- (define-key evil-operator-state-local-map "s" 'evil-test-square-motion)
- ("y2e2yyy3sjP\C-p\C-p2\C-n")
- ";; This buffer is for notes you don't want to save.
-\[;]; ;; If you want to create a file, visit that file with C-x C-f,
-;; ;; then enter the text in that file's own buffer.
-;;")))
-
-(ert-deftest evil-test-visual-paste ()
- "Test `evil-paste-before' and `evil-paste-after' in Visual state"
- :tags '(evil paste)
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; [I]f you want to create a file, visit that file with C-x C-f."
- ("yyk")
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f."
- ("VP")
- "[;]; If you want to create a file, visit that file with C-x C-f.
-;; If you want to create a file, visit that file with C-x C-f.")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f."
- ("yyj")
- ";; This buffer is for notes you don't want to save.
-;; [I]f you want to create a file, visit that file with C-x C-f."
- ("Vp")
- ";; This buffer is for notes you don't want to save.
-\[;]; This buffer is for notes you don't want to save."))
-
-(ert-deftest evil-test-visual-paste-pop ()
- "Test `evil-paste-pop' after visual paste."
- :tags '(evil paste)
- (ert-info ("Visual-char paste, char paste")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^jw")
- "word1a word1b word1c\nword2a [w]ord2b\nword3a word3b word3c word3d\n"
- ("viwp")
- "word1a word1b word1c\nword2a word1[b]\nword3a word3b word3c word3d\n"))
- (ert-info ("Visual-char paste, char paste, line pop")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^jw")
- "word1a word1b word1c\nword2a [w]ord2b\nword3a word3b word3c word3d\n"
- ("viwp\C-p")
- "word1a word1b word1c\nword2a \n[w]ord1a word1b word1c\n\nword3a word3b
word3c word3d\n"))
- (ert-info ("Visual-char paste, char paste, line pop, char pop")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^jw")
- "word1a word1b word1c\nword2a [w]ord2b\nword3a word3b word3c word3d\n"
- ("viwp\C-p\C-p")
- "word1a word1b word1c\nword2a word1[a]\nword3a word3b word3c word3d\n"))
- (ert-info ("Visual-line paste, char paste")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^j")
- "word1a word1b word1c\n[w]ord2a word2b\nword3a word3b word3c word3d\n"
- ("Vp")
- "word1a word1b word1c\nword1[b]word3a word3b word3c word3d\n"))
- (ert-info ("Visual-line paste, char paste, line pop")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^j")
- "word1a word1b word1c\n[w]ord2a word2b\nword3a word3b word3c word3d\n"
- ("Vp\C-p")
- "word1a word1b word1c\n[w]ord1a word1b word1c\nword3a word3b word3c
word3d\n"))
- (ert-info ("Visual-line paste, char paste, line pop, char pop")
- (evil-test-buffer
- "[w]ord1a word1b word1c\nword2a word2b\nword3a word3b word3c word3d\n"
- ("yiwyywyiw^j")
- "word1a word1b word1c\n[w]ord2a word2b\nword3a word3b word3c word3d\n"
- ("Vp\C-p\C-p")
- "word1a word1b word1c\nword1[a]word3a word3b word3c word3d\n")))
-
-(ert-deftest evil-test-register ()
- "Test yanking and pasting to and from register."
- :tags '(evil yank paste)
- (ert-info ("simple lower case register")
- (evil-test-buffer
- "[f]oo\n"
- ("\"ayw\"aP")
- "fo[o]foo\n"
- ("\"ayy\"aP")
- "[f]oofoo\nfoofoo\n"))
- (ert-info ("upper case register")
- (evil-test-buffer
- "[f]oo\n"
- ("\"ayw\"Ayw\"aP")
- "foofo[o]foo\n"
- ("\"ayy\"Ayy\"aP")
- "[f]oofoofoo\nfoofoofoo\nfoofoofoo\n"))
- (ert-info ("upper case register and lines")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4\n"
- ("\"a2Yjj\"A2Y\"aP")
- "line 1\nline 2\n[l]ine 1\nline 2\nline 3\nline 4\nline 3\nline 4\n"
- ("8G\"ap")
- "line 1\nline 2\nline 1\nline 2\nline 3\nline 4\nline 3\nline 4\n[l]ine
1\nline 2\nline 3\nline 4\n"))
- (ert-info ("yank with count")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\n"
- ("\"a2yw\"aP")
- "line [1]line 1\nline 2\nline 3\n"
- ("\"a2yy\"aP")
- "[l]ine 1line 1\nline 2\nline 1line 1\nline 2\nline 3\n"))
- (dolist (module '(evil-search isearch))
- (evil-select-search-module 'evil-search-module module)
- (ert-info ((format "special register / (module: %s)" module))
- (evil-test-buffer
- "[f]oo bar\n"
- ("/bar" [return] "0i\C-r/")
- "bar[f]oo bar\n")))
- (ert-info ("special register :")
- (evil-test-buffer
- "[f]oo bar\n"
- (":noh\ni\C-r:"))))
-
-(ert-deftest evil-test-last-insert-register ()
- "Test last insertion register."
- (evil-test-buffer
- "[l]ine 1\n"
- ("GiABC" [escape])
- "line 1\nAB[C]"
- ("gg\".P")
- "AB[C]line 1\nABC"))
-
-(ert-deftest evil-test-zero-register ()
- "\"0 contains the last text that was yanked without specificying a register."
- (evil-test-buffer
- "[l]ine 1\nline 2\n"
- ("yy\"0p")
- "line 1\n[l]ine 1\nline 2\n"
- ("j\"ayy\"0p")
- "line 1\nline 1\nline 2\n[l]ine 1\n" ; yanked line 2 to "a, so "0 is still
line 1
- ("kdd\"0p")
- "line 1\nline 1\nline 1\n[l]ine 1\n"))
-
-(ert-deftest evil-test-align ()
- "Test `evil-align-left', `evil-align-right' and `evil-align-center'."
- :tags '(evil operator)
- (evil-without-display
- (let ((fill-column 70)
- indent-tabs-mode)
- (evil-test-buffer
- "before\n[l]ine 1\nthis is line number 2\nline number 3\nafter\n"
- (":.,+2ri" [return] (kbd "M-x") "untabify" [return])
- "before\n
[l]ine 1\n this is line
number 2\n line number
3\nafter\n"
- (":.,+2ri 60" [return] (kbd "M-x") "untabify" [return])
- "before\n [l]ine
1\n this is line number 2\n
line number 3\nafter\n"
- (":.,+2le" [return] (kbd "M-x") "untabify" [return])
- "before\n[l]ine 1\nthis is line number 2\nline number 3\nafter\n"
- (":.,+2le 10" [return])
- "before\n [l]ine 1\n this is line number 2\n
line number 3\nafter\n"
- (":.,+2ce" [return] (kbd "M-x") "untabify" [return])
- "before\n [l]ine 1\n
this is line number 2\n line number 3\nafter\n"
- (":.,+2ce 40" [return] (kbd "M-x") "untabify" [return])
- "before\n [l]ine 1\n this is line number 2\n
line number 3\nafter\n"))))
-
-;;; Motions
-
-(ert-deftest evil-test-forward-char ()
- "Test `evil-forward-char' motion"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("l")
- ";[;] This buffer is for notes."))
- (ert-info ("End of line")
- (let ((evil-cross-lines t)
- (evil-move-cursor-back t))
- (evil-test-buffer
- ";; This buffer is for notes[,]
-;; and for Lisp evaluation."
- ("l")
- ";; This buffer is for notes,
-\[;]; and for Lisp evaluation.")))
- (ert-info ("With count")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("12l")
- ";; This buff[e]r is for notes."))
- (ert-info ("End of line")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- (should-error (execute-kbd-macro "l"))
- (should-error (execute-kbd-macro "10l"))))
- (ert-info ("Until end-of-line")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("100l")
- ";; This buffer is for notes[.]"))
- (ert-info ("On empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- (should-error (execute-kbd-macro "l"))
- (should-error (execute-kbd-macro "42l")))))
-
-(ert-deftest evil-test-backward-char ()
- "Test `evil-backward-char' motion"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This[ ]buffer is for notes."
- ("h")
- ";; Thi[s] buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This[ ]buffer is for notes."
- ("3h")
- ";; T[h]is buffer is for notes."))
- (ert-info ("Beginning of line")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (should-error (execute-kbd-macro "h"))
- (should-error (execute-kbd-macro "10h"))))
- (ert-info ("Until beginning-of-line")
- (evil-test-buffer
- ";; This[ ]buffer is for notes."
- ("100h")
- "[;]; This buffer is for notes."))
- (ert-info ("On empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- (should-error (execute-kbd-macro "h"))
- (should-error (execute-kbd-macro "42h")))))
-
-(ert-deftest evil-test-previous-line ()
- "Test `evil-previous-line' motion"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save,
-;; [a]nd for Lisp evaluation."
- ("k")
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; [t]hen enter the text in that file's own buffer."
- ("2k")
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("Until beginning of buffer")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; [t]hen enter the text in that file's own buffer."
- ("100k")
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."))
- (ert-info ("At beginning of buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- (should-error (execute-kbd-macro "k"))
- (should-error (execute-kbd-macro "42k")))))
-
-(ert-deftest evil-test-next-line ()
- "Test `evil-next-line' motion"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("j")
- ";; This buffer is for notes you don't want to save,
-;; [a]nd for Lisp evaluation."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("2j")
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; [t]hen enter the text in that file's own buffer."))
- (ert-info ("Until end of buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("100j")
- ";; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; [t]hen enter the text in that file's own buffer."))
- (ert-info ("At end of buffer")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to [s]ave."
- (should-error (execute-kbd-macro "j"))
- (should-error (execute-kbd-macro "42j")))))
-
-(ert-deftest evil-test-preserve-column ()
- "Test `evil-previous-line' and `evil-next-line' preserve the column."
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "ab[c]\nabcdef\n\nabcd\n"
- ("j")
- "abc\nab[c]def\n\nabcd\n")
- (evil-test-buffer
- "ab[c]\nabcdef\n\nabcd\n"
- ("jj")
- "abc\nabcdef\n[\n]abcd\n")
- (evil-test-buffer
- "ab[c]\nabcdef\n\nabcd\n"
- ("jjj")
- "abc\nabcdef\n\nab[c]d\n")
- (evil-test-buffer
- "ab[c]\nabcdef\n\nabcd\n"
- ("jjjk")
- "abc\nabcdef\n[\n]abcd\n")
- (evil-test-buffer
- "ab[c]\nabcdef\n\nabcd\n"
- ("jjjkk")
- "abc\nab[c]def\n\nabcd\n")))
-
-(ert-deftest evil-test-beginning-of-line ()
- "Test `evil-beginning-of-line' motion"
- :tags '(evil motion)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("0")
- "[;]; This buffer is for notes you don't want to save."
- ("0")
- "[;]; This buffer is for notes you don't want to save."))
-
-(ert-deftest evil-test-end-of-line ()
- "Test `evil-end-of-line' motion"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save."
- ("$")
- ";; This buffer is for notes you don't want to save[.]"
- ("$")
- ";; This buffer is for notes you don't want to save[.]"))
- (ert-info ("Don't delete blank lines")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("d$")
- "Above some line
-\[]
-Below some empty line")))
-
-(ert-deftest evil-test-first-non-blank ()
- "Test `evil-first-non-blank' motion"
- :tags '(evil motion)
- (evil-test-buffer
- "\
- printf(\"Hello world\\n\")[;]
- return EXIT_SUCCESS;"
- ("^")
- "\
- [p]rintf(\"Hello world\\n\");
- return EXIT_SUCCESS;"
- ("j^")
- "\
- printf(\"Hello world\\n\");
- [r]eturn EXIT_SUCCESS;"))
-
-(ert-deftest evil-test-last-non-blank ()
- "Test `evil-last-non-blank' motion"
- :tags '(evil motion)
- (evil-test-buffer
- "[i]nt main(int argc, char** argv) \n\
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("g_")
- "int main(int argc, char** argv[)] \n\
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("jjg_")
- "int main(int argc, char** argv) \n\
-{
- printf(\"Hello world\\n\")[;]
- return EXIT_SUCCESS;
-}"))
-
-(ert-deftest evil-test-goto-first-line ()
- "Test `evil-goto-first-line' motion"
- :tags '(evil motion)
- (evil-test-buffer
- "[i]nt main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("3gg")
- "int main(int argc, char** argv)
-{
- [p]rintf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("gg")
- "[i]nt main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("100gg")
- "int main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-\[}]"))
-
-(ert-deftest evil-test-goto-line ()
- "Test `evil-goto-line' motion"
- :tags '(evil motion)
- (evil-test-buffer
- "[i]nt main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("G")
- "int main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-\[}]"
- ("3G")
- "int main(int argc, char** argv)
-{
- [p]rintf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("100G")
- "int main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-\[}]"))
-
-(ert-deftest evil-test-operator-0 ()
- "Test motion \"0\" with an operator."
- :tags '(evil motion)
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("d0")
- "[T]his buffer is for notes."))
-
-(ert-deftest evil-test-forward-not-word ()
- "Test `evil-forward-not-thing'"
- :tags '(evil motion)
- (evil-test-buffer
- "[ ] aa,,"
- (evil-forward-not-thing 'evil-word)
- " [a]a,,"))
-
-;; TODO: test Visual motions and window motions
-(ert-deftest evil-test-forward-word-begin ()
- "Test `evil-forward-word-begin'"
- :tags '(evil motion)
- (ert-info ("Non-word")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("w")
- ";; [T]his buffer is for notes."))
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("w")
- ";; This [b]uffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("3w")
- ";; This buffer is [f]or notes."))
- (ert-info ("With count on whitespace")
- (evil-test-buffer
- ";;[ ]This buffer is for notes."
- ("3w")
- ";; This buffer [i]s for notes."))
- (ert-info ("Empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("w")
- "Above some line
-
-\[B]elow some empty line")
- (evil-test-buffer
- "[A]bove
-
-Below some empty line"
- ("dw")
- "[]
-
-Below some empty line"
- ("dw")
- "[]
-Below some empty line"
- ("dw")
- "[B]elow some empty line")
- (evil-test-buffer
- "[A]bove
-
- Below some empty line with leading whitespace"
- ("dw")
- "[]
-
- Below some empty line with leading whitespace"
- ("dw")
- "[]
- Below some empty line with leading whitespace"
- ("dw")
- " [B]elow some empty line")
- (evil-test-buffer
- "Some line with trailing whitespace [ ] \n next line\n"
- ("dw")
- "Some line with trailing whitespace [ ]\n next line\n")
- (evil-test-buffer
- "[A]\n"
- ("dw")
- "[]\n"))
- (ert-info ("End of buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("100w")
- ";; This buffer is for notes[.]"
- (should-error (execute-kbd-macro "w"))
- (should-error (execute-kbd-macro "10w"))))
- (ert-info ("Before last character in buffer")
- (evil-test-buffer
- "fo[o]."
- ("w")
- "foo[.]")
- (evil-test-buffer
- "fo[o] "
- ("w")
- "foo[ ]")
- (evil-test-buffer
- "[ ]e"
- ("w")
- " [e]")))
-
-(ert-deftest evil-test-forward-word-end ()
- "Test `evil-forward-word-end'"
- :tags '(evil motion)
- (ert-info ("Non-word")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("e")
- ";[;] This buffer is for notes."))
- (ert-info ("Simple")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("e")
- ";; Thi[s] buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("3e")
- ";; This buffer i[s] for notes."))
- (ert-info ("With count on whitespace")
- (evil-test-buffer
- ";;[ ]This buffer is for notes."
- ("3e")
- ";; This buffer i[s] for notes."))
- (ert-info ("Delete")
- (evil-test-buffer
- ";; This[-]buffer-is-for-notes."
- ("de")
- ";; This[-]is-for-notes."))
- (ert-info ("Empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("e")
- "Above some line
-
-Belo[w] some empty line"))
- (ert-info ("End of buffer")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("100e")
- ";; This buffer is for notes[.]"
- (should-error (execute-kbd-macro "e"))
- (should-error (execute-kbd-macro "10e"))))
- ;; In Vim, "de" may delete two words rather than one
- ;; if the first word is only one letter. In Evil,
- ;; "de" always deletes one word.
- (ert-info ("Delete a single-letter word")
- (evil-test-buffer
- "a [b] c"
- ("de")
- "a [ ]c")))
-
-(ert-deftest evil-test-backward-word-begin ()
- "Test `evil-backward-word-begin'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("b")
- ";; This buffer is for [n]otes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2b")
- ";; This buffer is [f]or notes."))
- (ert-info ("Empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("b")
- "Above some [l]ine
-
-Below some empty line"))
- (ert-info ("With count on whitespace")
- (evil-test-buffer
- ";; This buffer is for[ ]notes."
- ("2b")
- ";; This buffer [i]s for notes."))
- (ert-info ("Beginning of buffer")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("100b")
- "[;]; This buffer is for notes."
- (should-error (execute-kbd-macro "b"))
- (should-error (execute-kbd-macro "10b")))))
-
-(ert-deftest evil-test-backward-word-end ()
- "Test `evil-backward-word-end'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("ge")
- ";; This buffer is for note[s]."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2ge")
- ";; This buffer is fo[r] notes."))
- (ert-info ("Empty line")
- (evil-test-buffer
- "Above some line
-\[]
-Below some empty line"
- ("ge")
- "Above some lin[e]
-
-Below some empty line"))
- (ert-info ("With count on whitespace")
- (evil-test-buffer
- ";; This buffer is for[ ]notes."
- ("2ge")
- ";; This buffer i[s] for notes."))
- (ert-info ("Beginning of buffer")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("100ge")
- "[;]; This buffer is for notes."
- (should-error (execute-kbd-macro "ge"))
- (should-error (execute-kbd-macro "10ge")))))
-
-(ert-deftest evil-test-forward-word-begin-cjk ()
- "Test `evil-forward-word-begin' on CJK words"
- :tags '(evil motion cjk)
- (ert-info ("Latin / numeric")
- (evil-test-buffer
- "[a]bcd1234"
- ("w")
- "abcd123[4]"))
- (ert-info ("Latin / Kanji")
- (evil-test-buffer
- "[a]bcd漢字"
- ("w")
- "abcd[漢]字"))
- (ert-info ("Latin / Hiragana")
- (evil-test-buffer
- "[a]bcdひらがな"
- ("w")
- "abcd[ひ]らがな"))
- (ert-info ("Latin / Katakana")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("w")
- "abcd[カ]タカナ"))
- (ert-info ("Latin / half-width Katakana")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("w")
- "abcdカタカ[ナ]"))
- (ert-info ("Latin / full-width alphabet")
- (evil-test-buffer
- "[a]bcdABC"
- ("w")
- "abcdAB[C]"))
- (ert-info ("Latin / full-width numeric")
- (evil-test-buffer
- "[a]bcd123"
- ("w")
- "abcd12[3]"))
- (ert-info ("Latin / Hangul")
- (evil-test-buffer
- "[a]bcd한글"
- ("w")
- "abcd[한]글"))
- (ert-info ("numeric / Latin")
- (evil-test-buffer
- "[1]234abcd"
- ("w")
- "1234abc[d]"))
- (ert-info ("numeric / Kanji")
- (evil-test-buffer
- "[1]234漢字"
- ("w")
- "1234[漢]字"))
- (ert-info ("numeric / Hiragana")
- (evil-test-buffer
- "[1]234ひらがな"
- ("w")
- "1234[ひ]らがな"))
- (ert-info ("numeric / Katakana")
- (evil-test-buffer
- "[1]234カタカナ"
- ("w")
- "1234[カ]タカナ"))
- (ert-info ("numeric / half-width Katakana")
- (evil-test-buffer
- "[1]234カタカナ"
- ("w")
- "1234カタカ[ナ]"))
- (ert-info ("numeric / full-width alphabet")
- (evil-test-buffer
- "[1]234ABC"
- ("w")
- "1234AB[C]"))
- (ert-info ("numeric / full-width numeric")
- (evil-test-buffer
- "[1]234123"
- ("w")
- "123412[3]"))
- (ert-info ("numeric / Hangul")
- (evil-test-buffer
- "[1]234한글"
- ("w")
- "1234[한]글"))
- (ert-info ("Kanji / Latin")
- (evil-test-buffer
- "[漢]字abcd"
- ("w")
- "漢字[a]bcd"))
- (ert-info ("Kanji / numeric")
- (evil-test-buffer
- "[漢]字1234"
- ("w")
- "漢字[1]234"))
- (ert-info ("Kanji / Hiragana")
- (evil-test-buffer
- "[漢]字ひらがな"
- ("w")
- "漢字[ひ]らがな"))
- (ert-info ("Kanji / Katakana")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("w")
- "漢字[カ]タカナ"))
- (ert-info ("Kanji / half-width Katakana")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("w")
- "漢字[カ]タカナ"))
- (ert-info ("Kanji / full-width alphabet")
- (evil-test-buffer
- "[漢]字ABC"
- ("w")
- "漢字[A]BC"))
- (ert-info ("Kanji / full-width numeric")
- (evil-test-buffer
- "[漢]字123"
- ("w")
- "漢字[1]23"))
- (ert-info ("Kanji / Hangul")
- (evil-test-buffer
- "[漢]字한글"
- ("w")
- "漢字[한]글"))
- (ert-info ("Hiragana / Latin")
- (evil-test-buffer
- "[ひ]らがなabcd"
- ("w")
- "ひらがな[a]bcd"))
- (ert-info ("Hiragana / numeric")
- (evil-test-buffer
- "[ひ]らがな1234"
- ("w")
- "ひらがな[1]234"))
- (ert-info ("Hiragana / Kanji")
- (evil-test-buffer
- "[ひ]らがな漢字"
- ("w")
- "ひらがな[漢]字"))
- (ert-info ("Hiragana / Katakana")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("w")
- "ひらがな[カ]タカナ"))
- (ert-info ("Hiragana / half-width Katakana")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("w")
- "ひらがな[カ]タカナ"))
- (ert-info ("Hiragana / full-width alphabet")
- (evil-test-buffer
- "[ひ]らがなABC"
- ("w")
- "ひらがな[A]BC"))
- (ert-info ("Hiragana / full-width numeric")
- (evil-test-buffer
- "[ひ]らがな123"
- ("w")
- "ひらがな[1]23"))
- (ert-info ("Hiragana / Hangul")
- (evil-test-buffer
- "[ひ]らがな한글"
- ("w")
- "ひらがな[한]글"))
- (ert-info ("Katakana / Latin")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("w")
- "カタカナ[a]bcd"))
- (ert-info ("Katakana / numeric")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("w")
- "カタカナ[1]234"))
- (ert-info ("Katakana / Kanji")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("w")
- "カタカナ[漢]字"))
- (ert-info ("Katakana / Hiragana")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("w")
- "カタカナ[ひ]らがな"))
- (ert-info ("Katakana / half-width Katakana")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("w")
- "カタカナ[カ]タカナ"))
- (ert-info ("Katakana / full-width alphabet")
- (evil-test-buffer
- "[カ]タカナABC"
- ("w")
- "カタカナ[A]BC"))
- (ert-info ("Katakana / full-width numeric")
- (evil-test-buffer
- "[カ]タカナ123"
- ("w")
- "カタカナ[1]23"))
- (ert-info ("Katakana / Hangul")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("w")
- "カタカナ[한]글"))
- (ert-info ("half-width Katakana / Latin")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("w")
- "カタカナabc[d]"))
- (ert-info ("half-width Katakana / numeric")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("w")
- "カタカナ123[4]"))
- (ert-info ("half-width Katakana / Kanji")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("w")
- "カタカナ[漢]字"))
- (ert-info ("half-width Katakana / Hiragana")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("w")
- "カタカナ[ひ]らがな"))
- (ert-info ("half-width Katakana / Katakana")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("w")
- "カタカナ[カ]タカナ"))
- (ert-info ("half-width Katakana / full-width alphabet")
- (evil-test-buffer
- "[カ]タカナABC"
- ("w")
- "カタカナAB[C]"))
- (ert-info ("half-width Katakana / full-width numeric")
- (evil-test-buffer
- "[カ]タカナ123"
- ("w")
- "カタカナ12[3]"))
- (ert-info ("half-width Katakana / Hangul")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("w")
- "カタカナ[한]글"))
- (ert-info ("full-width alphabet / Latin")
- (evil-test-buffer
- "[A]BCabcd"
- ("w")
- "ABCabc[d]"))
- (ert-info ("full-width alphabet / numeric")
- (evil-test-buffer
- "[A]BC1234"
- ("w")
- "ABC123[4]"))
- (ert-info ("full-width alphabet / Kanji")
- (evil-test-buffer
- "[A]BC漢字"
- ("w")
- "ABC[漢]字"))
- (ert-info ("full-width alphabet / Hiragana")
- (evil-test-buffer
- "[A]BCひらがな"
- ("w")
- "ABC[ひ]らがな"))
- (ert-info ("full-width alphabet / Katakana")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("w")
- "ABC[カ]タカナ"))
- (ert-info ("full-width alphabet / half-width Katakana")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("w")
- "ABCカタカ[ナ]"))
- (ert-info ("full-width alphabet / full-width numeric")
- (evil-test-buffer
- "[A]BC123"
- ("w")
- "ABC12[3]"))
- (ert-info ("full-width alphabet / Hangul")
- (evil-test-buffer
- "[A]BC한글"
- ("w")
- "ABC[한]글"))
- (ert-info ("full-width numeric / Latin")
- (evil-test-buffer
- "[1]23abcd"
- ("w")
- "123abc[d]"))
- (ert-info ("full-width numeric / numeric")
- (evil-test-buffer
- "[1]231234"
- ("w")
- "123123[4]"))
- (ert-info ("full-width numeric / Kanji")
- (evil-test-buffer
- "[1]23漢字"
- ("w")
- "123[漢]字"))
- (ert-info ("full-width numeric / Hiragana")
- (evil-test-buffer
- "[1]23ひらがな"
- ("w")
- "123[ひ]らがな"))
- (ert-info ("full-width numeric / Katakana")
- (evil-test-buffer
- "[1]23カタカナ"
- ("w")
- "123[カ]タカナ"))
- (ert-info ("full-width numeric / half-width Katakana")
- (evil-test-buffer
- "[1]23カタカナ"
- ("w")
- "123カタカ[ナ]"))
- (ert-info ("full-width numeric / full-width alphabet")
- (evil-test-buffer
- "[1]23ABC"
- ("w")
- "123AB[C]"))
- (ert-info ("full-width numeric / Hangul")
- (evil-test-buffer
- "[1]23한글"
- ("w")
- "123[한]글"))
- (ert-info ("Hangul / Latin")
- (evil-test-buffer
- "[한]글abcd"
- ("w")
- "한글[a]bcd"))
- (ert-info ("Hangul / numeric")
- (evil-test-buffer
- "[한]글1234"
- ("w")
- "한글[1]234"))
- (ert-info ("Hangul / Kanji")
- (evil-test-buffer
- "[한]글漢字"
- ("w")
- "한글[漢]字"))
- (ert-info ("Hangul / Hiragana")
- (evil-test-buffer
- "[한]글ひらがな"
- ("w")
- "한글[ひ]らがな"))
- (ert-info ("Hangul / Katakana")
- (evil-test-buffer
- "[한]글カタカナ"
- ("w")
- "한글[カ]タカナ"))
- (ert-info ("Hangul / half-width Katakana")
- (evil-test-buffer
- "[한]글カタカナ"
- ("w")
- "한글[カ]タカナ"))
- (ert-info ("Hangul / full-width alphabet")
- (evil-test-buffer
- "[한]글ABC"
- ("w")
- "한글[A]BC"))
- (ert-info ("Hangul / full-width numeric")
- (evil-test-buffer
- "[한]글123"
- ("w")
- "한글[1]23")))
-
-(ert-deftest evil-test-forward-word-end-cjk ()
- "Test `evil-forward-word-end' on CJK words"
- :tags '(evil motion cjk)
- (ert-info ("Latin / numeric")
- (evil-test-buffer
- "[a]bcd1234"
- ("e")
- "abcd123[4]"))
- (ert-info ("Latin / Kanji")
- (evil-test-buffer
- "[a]bcd漢字"
- ("e")
- "abc[d]漢字"))
- (ert-info ("Latin / Hiragana")
- (evil-test-buffer
- "[a]bcdひらがな"
- ("e")
- "abc[d]ひらがな"))
- (ert-info ("Latin / Katakana")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("e")
- "abc[d]カタカナ"))
- (ert-info ("Latin / half-width Katakana")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("e")
- "abcdカタカ[ナ]"))
- (ert-info ("Latin / full-width alphabet")
- (evil-test-buffer
- "[a]bcdABC"
- ("e")
- "abcdAB[C]"))
- (ert-info ("Latin / full-width numeric")
- (evil-test-buffer
- "[a]bcd123"
- ("e")
- "abcd12[3]"))
- (ert-info ("Latin / Hangul")
- (evil-test-buffer
- "[a]bcd한글"
- ("e")
- "abc[d]한글"))
- (ert-info ("numeric / Latin")
- (evil-test-buffer
- "[1]234abcd"
- ("e")
- "1234abc[d]"))
- (ert-info ("numeric / Kanji")
- (evil-test-buffer
- "[1]234漢字"
- ("e")
- "123[4]漢字"))
- (ert-info ("numeric / Hiragana")
- (evil-test-buffer
- "[1]234ひらがな"
- ("e")
- "123[4]ひらがな"))
- (ert-info ("numeric / Katakana")
- (evil-test-buffer
- "[1]234カタカナ"
- ("e")
- "123[4]カタカナ"))
- (ert-info ("numeric / half-width Katakana")
- (evil-test-buffer
- "[1]234カタカナ"
- ("e")
- "1234カタカ[ナ]"))
- (ert-info ("numeric / full-width alphabet")
- (evil-test-buffer
- "[1]234ABC"
- ("e")
- "1234AB[C]"))
- (ert-info ("numeric / full-width numeric")
- (evil-test-buffer
- "[1]234123"
- ("e")
- "123412[3]"))
- (ert-info ("numeric / Hangul")
- (evil-test-buffer
- "[1]234한글"
- ("e")
- "123[4]한글"))
- (ert-info ("Kanji / Latin")
- (evil-test-buffer
- "[漢]字abcd"
- ("e")
- "漢[字]abcd"))
- (ert-info ("Kanji / numeric")
- (evil-test-buffer
- "[漢]字1234"
- ("e")
- "漢[字]1234"))
- (ert-info ("Kanji / Hiragana")
- (evil-test-buffer
- "[漢]字ひらがな"
- ("e")
- "漢[字]ひらがな"))
- (ert-info ("Kanji / Katakana")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("e")
- "漢[字]カタカナ"))
- (ert-info ("Kanji / half-width Katakana")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("e")
- "漢[字]カタカナ"))
- (ert-info ("Kanji / full-width alphabet")
- (evil-test-buffer
- "[漢]字ABC"
- ("e")
- "漢[字]ABC"))
- (ert-info ("Kanji / full-width numeric")
- (evil-test-buffer
- "[漢]字123"
- ("e")
- "漢[字]123"))
- (ert-info ("Kanji / Hangul")
- (evil-test-buffer
- "[漢]字한글"
- ("e")
- "漢[字]한글"))
- (ert-info ("Hiragana / Latin")
- (evil-test-buffer
- "[ひ]らがなabcd"
- ("e")
- "ひらが[な]abcd"))
- (ert-info ("Hiragana / numeric")
- (evil-test-buffer
- "[ひ]らがな1234"
- ("e")
- "ひらが[な]1234"))
- (ert-info ("Hiragana / Kanji")
- (evil-test-buffer
- "[ひ]らがな漢字"
- ("e")
- "ひらが[な]漢字"))
- (ert-info ("Hiragana / Katakana")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("e")
- "ひらが[な]カタカナ"))
- (ert-info ("Hiragana / half-width Katakana")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("e")
- "ひらが[な]カタカナ"))
- (ert-info ("Hiragana / full-width alphabet")
- (evil-test-buffer
- "[ひ]らがなABC"
- ("e")
- "ひらが[な]ABC"))
- (ert-info ("Hiragana / full-width numeric")
- (evil-test-buffer
- "[ひ]らがな123"
- ("e")
- "ひらが[な]123"))
- (ert-info ("Hiragana / Hangul")
- (evil-test-buffer
- "[ひ]らがな한글"
- ("e")
- "ひらが[な]한글"))
- (ert-info ("Katakana / Latin")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("e")
- "カタカ[ナ]abcd"))
- (ert-info ("Katakana / numeric")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("e")
- "カタカ[ナ]1234"))
- (ert-info ("Katakana / Kanji")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("e")
- "カタカ[ナ]漢字"))
- (ert-info ("Katakana / Hiragana")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("e")
- "カタカ[ナ]ひらがな"))
- (ert-info ("Katakana / half-width Katakana")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("e")
- "カタカ[ナ]カタカナ"))
- (ert-info ("Katakana / full-width alphabet")
- (evil-test-buffer
- "[カ]タカナABC"
- ("e")
- "カタカ[ナ]ABC"))
- (ert-info ("Katakana / full-width numeric")
- (evil-test-buffer
- "[カ]タカナ123"
- ("e")
- "カタカ[ナ]123"))
- (ert-info ("Katakana / Hangul")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("e")
- "カタカ[ナ]한글"))
- (ert-info ("half-width Katakana / Latin")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("e")
- "カタカナabc[d]"))
- (ert-info ("half-width Katakana / numeric")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("e")
- "カタカナ123[4]"))
- (ert-info ("half-width Katakana / Kanji")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("e")
- "カタカ[ナ]漢字"))
- (ert-info ("half-width Katakana / Hiragana")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("e")
- "カタカ[ナ]ひらがな"))
- (ert-info ("half-width Katakana / Katakana")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("e")
- "カタカ[ナ]カタカナ"))
- (ert-info ("half-width Katakana / full-width alphabet")
- (evil-test-buffer
- "[カ]タカナABC"
- ("e")
- "カタカナAB[C]"))
- (ert-info ("half-width Katakana / full-width numeric")
- (evil-test-buffer
- "[カ]タカナ123"
- ("e")
- "カタカナ12[3]"))
- (ert-info ("half-width Katakana / Hangul")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("e")
- "カタカ[ナ]한글"))
- (ert-info ("full-width alphabet / Latin")
- (evil-test-buffer
- "[A]BCabcd"
- ("e")
- "ABCabc[d]"))
- (ert-info ("full-width alphabet / numeric")
- (evil-test-buffer
- "[A]BC1234"
- ("e")
- "ABC123[4]"))
- (ert-info ("full-width alphabet / Kanji")
- (evil-test-buffer
- "[A]BC漢字"
- ("e")
- "AB[C]漢字"))
- (ert-info ("full-width alphabet / Hiragana")
- (evil-test-buffer
- "[A]BCひらがな"
- ("e")
- "AB[C]ひらがな"))
- (ert-info ("full-width alphabet / Katakana")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("e")
- "AB[C]カタカナ"))
- (ert-info ("full-width alphabet / half-width Katakana")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("e")
- "ABCカタカ[ナ]"))
- (ert-info ("full-width alphabet / full-width numeric")
- (evil-test-buffer
- "[A]BC123"
- ("e")
- "ABC12[3]"))
- (ert-info ("full-width alphabet / Hangul")
- (evil-test-buffer
- "[A]BC한글"
- ("e")
- "AB[C]한글"))
- (ert-info ("full-width numeric / Latin")
- (evil-test-buffer
- "[1]23abcd"
- ("e")
- "123abc[d]"))
- (ert-info ("full-width numeric / numeric")
- (evil-test-buffer
- "[1]231234"
- ("e")
- "123123[4]"))
- (ert-info ("full-width numeric / Kanji")
- (evil-test-buffer
- "[1]23漢字"
- ("e")
- "12[3]漢字"))
- (ert-info ("full-width numeric / Hiragana")
- (evil-test-buffer
- "[1]23ひらがな"
- ("e")
- "12[3]ひらがな"))
- (ert-info ("full-width numeric / Katakana")
- (evil-test-buffer
- "[1]23カタカナ"
- ("e")
- "12[3]カタカナ"))
- (ert-info ("full-width numeric / half-width Katakana")
- (evil-test-buffer
- "[1]23カタカナ"
- ("e")
- "123カタカ[ナ]"))
- (ert-info ("full-width numeric / full-width alphabet")
- (evil-test-buffer
- "[1]23ABC"
- ("e")
- "123AB[C]"))
- (ert-info ("full-width numeric / Hangul")
- (evil-test-buffer
- "[1]23한글"
- ("e")
- "12[3]한글"))
- (ert-info ("Hangul / Latin")
- (evil-test-buffer
- "[한]글abcd"
- ("e")
- "한[글]abcd"))
- (ert-info ("Hangul / numeric")
- (evil-test-buffer
- "[한]글1234"
- ("e")
- "한[글]1234"))
- (ert-info ("Hangul / Kanji")
- (evil-test-buffer
- "[한]글漢字"
- ("e")
- "한[글]漢字"))
- (ert-info ("Hangul / Hiragana")
- (evil-test-buffer
- "[한]글ひらがな"
- ("e")
- "한[글]ひらがな"))
- (ert-info ("Hangul / Katakana")
- (evil-test-buffer
- "[한]글カタカナ"
- ("e")
- "한[글]カタカナ"))
- (ert-info ("Hangul / half-width Katakana")
- (evil-test-buffer
- "[한]글カタカナ"
- ("e")
- "한[글]カタカナ"))
- (ert-info ("Hangul / full-width alphabet")
- (evil-test-buffer
- "[한]글ABC"
- ("e")
- "한[글]ABC"))
- (ert-info ("Hangul / full-width numeric")
- (evil-test-buffer
- "[한]글123"
- ("e")
- "한[글]123")))
-
-(ert-deftest evil-test-backword-word-begin-cjk ()
- "Test `evil-backward-word-begin' on CJK words"
- :tags '(evil motion cjk)
- (ert-info ("Latin / numeric")
- (evil-test-buffer
- "abcd123[4]"
- ("b")
- "[a]bcd1234"))
- (ert-info ("Latin / Kanji")
- (evil-test-buffer
- "abcd漢[字]"
- ("b")
- "abcd[漢]字"))
- (ert-info ("Latin / Hiragana")
- (evil-test-buffer
- "abcdひらが[な]"
- ("b")
- "abcd[ひ]らがな"))
- (ert-info ("Latin / Katakana")
- (evil-test-buffer
- "abcdカタカ[ナ]"
- ("b")
- "abcd[カ]タカナ"))
- (ert-info ("Latin / half-width Katakana")
- (evil-test-buffer
- "abcdカタカ[ナ]"
- ("b")
- "[a]bcdカタカナ"))
- (ert-info ("Latin / full-width alphabet")
- (evil-test-buffer
- "abcdAB[C]"
- ("b")
- "[a]bcdABC"))
- (ert-info ("Latin / full-width numeric")
- (evil-test-buffer
- "abcd12[3]"
- ("b")
- "[a]bcd123"))
- (ert-info ("Latin / Hangul")
- (evil-test-buffer
- "abcd한[글]"
- ("b")
- "abcd[한]글"))
- (ert-info ("numeric / Latin")
- (evil-test-buffer
- "1234abc[d]"
- ("b")
- "[1]234abcd"))
- (ert-info ("numeric / Kanji")
- (evil-test-buffer
- "1234漢[字]"
- ("b")
- "1234[漢]字"))
- (ert-info ("numeric / Hiragana")
- (evil-test-buffer
- "1234ひらが[な]"
- ("b")
- "1234[ひ]らがな"))
- (ert-info ("numeric / Katakana")
- (evil-test-buffer
- "1234カタカ[ナ]"
- ("b")
- "1234[カ]タカナ"))
- (ert-info ("numeric / half-width Katakana")
- (evil-test-buffer
- "1234カタカ[ナ]"
- ("b")
- "[1]234カタカナ"))
- (ert-info ("numeric / full-width alphabet")
- (evil-test-buffer
- "1234AB[C]"
- ("b")
- "[1]234ABC"))
- (ert-info ("numeric / full-width numeric")
- (evil-test-buffer
- "123412[3]"
- ("b")
- "[1]234123"))
- (ert-info ("numeric / Hangul")
- (evil-test-buffer
- "1234한[글]"
- ("b")
- "1234[한]글"))
- (ert-info ("Kanji / Latin")
- (evil-test-buffer
- "漢字abc[d]"
- ("b")
- "漢字[a]bcd"))
- (ert-info ("Kanji / numeric")
- (evil-test-buffer
- "漢字123[4]"
- ("b")
- "漢字[1]234"))
- (ert-info ("Kanji / Hiragana")
- (evil-test-buffer
- "漢字ひらが[な]"
- ("b")
- "漢字[ひ]らがな"))
- (ert-info ("Kanji / Katakana")
- (evil-test-buffer
- "漢字カタカ[ナ]"
- ("b")
- "漢字[カ]タカナ"))
- (ert-info ("Kanji / half-width Katakana")
- (evil-test-buffer
- "漢字カタカ[ナ]"
- ("b")
- "漢字[カ]タカナ"))
- (ert-info ("Kanji / full-width alphabet")
- (evil-test-buffer
- "漢字AB[C]"
- ("b")
- "漢字[A]BC"))
- (ert-info ("Kanji / full-width numeric")
- (evil-test-buffer
- "漢字12[3]"
- ("b")
- "漢字[1]23"))
- (ert-info ("Kanji / Hangul")
- (evil-test-buffer
- "漢字한[글]"
- ("b")
- "漢字[한]글"))
- (ert-info ("Hiragana / Latin")
- (evil-test-buffer
- "ひらがなabc[d]"
- ("b")
- "ひらがな[a]bcd"))
- (ert-info ("Hiragana / numeric")
- (evil-test-buffer
- "ひらがな123[4]"
- ("b")
- "ひらがな[1]234"))
- (ert-info ("Hiragana / Kanji")
- (evil-test-buffer
- "ひらがな漢[字]"
- ("b")
- "ひらがな[漢]字"))
- (ert-info ("Hiragana / Katakana")
- (evil-test-buffer
- "ひらがなカタカ[ナ]"
- ("b")
- "ひらがな[カ]タカナ"))
- (ert-info ("Hiragana / half-width Katakana")
- (evil-test-buffer
- "ひらがなカタカ[ナ]"
- ("b")
- "ひらがな[カ]タカナ"))
- (ert-info ("Hiragana / full-width alphabet")
- (evil-test-buffer
- "ひらがなAB[C]"
- ("b")
- "ひらがな[A]BC"))
- (ert-info ("Hiragana / full-width numeric")
- (evil-test-buffer
- "ひらがな12[3]"
- ("b")
- "ひらがな[1]23"))
- (ert-info ("Hiragana / Hangul")
- (evil-test-buffer
- "ひらがな한[글]"
- ("b")
- "ひらがな[한]글"))
- (ert-info ("Katakana / Latin")
- (evil-test-buffer
- "カタカナabc[d]"
- ("b")
- "カタカナ[a]bcd"))
- (ert-info ("Katakana / numeric")
- (evil-test-buffer
- "カタカナ123[4]"
- ("b")
- "カタカナ[1]234"))
- (ert-info ("Katakana / Kanji")
- (evil-test-buffer
- "カタカナ漢[字]"
- ("b")
- "カタカナ[漢]字"))
- (ert-info ("Katakana / Hiragana")
- (evil-test-buffer
- "カタカナひらが[な]"
- ("b")
- "カタカナ[ひ]らがな"))
- (ert-info ("Katakana / half-width Katakana")
- (evil-test-buffer
- "カタカナカタカ[ナ]"
- ("b")
- "カタカナ[カ]タカナ"))
- (ert-info ("Katakana / full-width alphabet")
- (evil-test-buffer
- "カタカナAB[C]"
- ("b")
- "カタカナ[A]BC"))
- (ert-info ("Katakana / full-width numeric")
- (evil-test-buffer
- "カタカナ12[3]"
- ("b")
- "カタカナ[1]23"))
- (ert-info ("Katakana / Hangul")
- (evil-test-buffer
- "カタカナ한[글]"
- ("b")
- "カタカナ[한]글"))
- (ert-info ("half-width Katakana / Latin")
- (evil-test-buffer
- "カタカナabc[d]"
- ("b")
- "[カ]タカナabcd"))
- (ert-info ("half-width Katakana / numeric")
- (evil-test-buffer
- "カタカナ123[4]"
- ("b")
- "[カ]タカナ1234"))
- (ert-info ("half-width Katakana / Kanji")
- (evil-test-buffer
- "カタカナ漢[字]"
- ("b")
- "カタカナ[漢]字"))
- (ert-info ("half-width Katakana / Hiragana")
- (evil-test-buffer
- "カタカナひらが[な]"
- ("b")
- "カタカナ[ひ]らがな"))
- (ert-info ("half-width Katakana / Katakana")
- (evil-test-buffer
- "カタカナカタカ[ナ]"
- ("b")
- "カタカナ[カ]タカナ"))
- (ert-info ("half-width Katakana / full-width alphabet")
- (evil-test-buffer
- "カタカナAB[C]"
- ("b")
- "[カ]タカナABC"))
- (ert-info ("half-width Katakana / full-width numeric")
- (evil-test-buffer
- "カタカナ12[3]"
- ("b")
- "[カ]タカナ123"))
- (ert-info ("half-width Katakana / Hangul")
- (evil-test-buffer
- "カタカナ한[글]"
- ("b")
- "カタカナ[한]글"))
- (ert-info ("full-width alphabet / Latin")
- (evil-test-buffer
- "ABCabc[d]"
- ("b")
- "[A]BCabcd"))
- (ert-info ("full-width alphabet / numeric")
- (evil-test-buffer
- "ABC123[4]"
- ("b")
- "[A]BC1234"))
- (ert-info ("full-width alphabet / Kanji")
- (evil-test-buffer
- "ABC漢[字]"
- ("b")
- "ABC[漢]字"))
- (ert-info ("full-width alphabet / Hiragana")
- (evil-test-buffer
- "ABCひらが[な]"
- ("b")
- "ABC[ひ]らがな"))
- (ert-info ("full-width alphabet / Katakana")
- (evil-test-buffer
- "ABCカタカ[ナ]"
- ("b")
- "ABC[カ]タカナ"))
- (ert-info ("full-width alphabet / half-width Katakana")
- (evil-test-buffer
- "ABCカタカ[ナ]"
- ("b")
- "[A]BCカタカナ"))
- (ert-info ("full-width alphabet / full-width numeric")
- (evil-test-buffer
- "ABC12[3]"
- ("b")
- "[A]BC123"))
- (ert-info ("full-width alphabet / Hangul")
- (evil-test-buffer
- "ABC한[글]"
- ("b")
- "ABC[한]글"))
- (ert-info ("full-width numeric / Latin")
- (evil-test-buffer
- "123abc[d]"
- ("b")
- "[1]23abcd"))
- (ert-info ("full-width numeric / numeric")
- (evil-test-buffer
- "123123[4]"
- ("b")
- "[1]231234"))
- (ert-info ("full-width numeric / Kanji")
- (evil-test-buffer
- "123漢[字]"
- ("b")
- "123[漢]字"))
- (ert-info ("full-width numeric / Hiragana")
- (evil-test-buffer
- "123ひらが[な]"
- ("b")
- "123[ひ]らがな"))
- (ert-info ("full-width numeric / Katakana")
- (evil-test-buffer
- "123カタカ[ナ]"
- ("b")
- "123[カ]タカナ"))
- (ert-info ("full-width numeric / half-width Katakana")
- (evil-test-buffer
- "123カタカ[ナ]"
- ("b")
- "[1]23カタカナ"))
- (ert-info ("full-width numeric / full-width alphabet")
- (evil-test-buffer
- "123AB[C]"
- ("b")
- "[1]23ABC"))
- (ert-info ("full-width numeric / Hangul")
- (evil-test-buffer
- "123한[글]"
- ("b")
- "123[한]글"))
- (ert-info ("Hangul / Latin")
- (evil-test-buffer
- "한글abc[d]"
- ("b")
- "한글[a]bcd"))
- (ert-info ("Hangul / numeric")
- (evil-test-buffer
- "한글123[4]"
- ("b")
- "한글[1]234"))
- (ert-info ("Hangul / Kanji")
- (evil-test-buffer
- "한글漢[字]"
- ("b")
- "한글[漢]字"))
- (ert-info ("Hangul / Hiragana")
- (evil-test-buffer
- "한글ひらが[な]"
- ("b")
- "한글[ひ]らがな"))
- (ert-info ("Hangul / Katakana")
- (evil-test-buffer
- "한글カタカ[ナ]"
- ("b")
- "한글[カ]タカナ"))
- (ert-info ("Hangul / half-width Katakana")
- (evil-test-buffer
- "한글カタカ[ナ]"
- ("b")
- "한글[カ]タカナ"))
- (ert-info ("Hangul / full-width alphabet")
- (evil-test-buffer
- "한글AB[C]"
- ("b")
- "한글[A]BC"))
- (ert-info ("Hangul / full-width numeric")
- (evil-test-buffer
- "한글12[3]"
- ("b")
- "한글[1]23")))
-
-(ert-deftest evil-test-backword-word-end-cjk ()
- "Test `evil-backward-word-end' on CJK words"
- :tags '(evil motion cjk)
- (ert-info ("Latin / numeric")
- (evil-test-buffer
- "abcd123[4]"
- ("ge")
- "[a]bcd1234"))
- (ert-info ("Latin / Kanji")
- (evil-test-buffer
- "abcd漢[字]"
- ("ge")
- "abc[d]漢字"))
- (ert-info ("Latin / Hiragana")
- (evil-test-buffer
- "abcdひらが[な]"
- ("ge")
- "abc[d]ひらがな"))
- (ert-info ("Latin / Katakana")
- (evil-test-buffer
- "abcdカタカ[ナ]"
- ("ge")
- "abc[d]カタカナ"))
- (ert-info ("Latin / half-width Katakana")
- (evil-test-buffer
- "abcdカタカ[ナ]"
- ("ge")
- "[a]bcdカタカナ"))
- (ert-info ("Latin / full-width alphabet")
- (evil-test-buffer
- "abcdAB[C]"
- ("ge")
- "[a]bcdABC"))
- (ert-info ("Latin / full-width numeric")
- (evil-test-buffer
- "abcd12[3]"
- ("ge")
- "[a]bcd123"))
- (ert-info ("Latin / Hangul")
- (evil-test-buffer
- "abcd한[글]"
- ("ge")
- "abc[d]한글"))
- (ert-info ("numeric / Latin")
- (evil-test-buffer
- "1234abc[d]"
- ("ge")
- "[1]234abcd"))
- (ert-info ("numeric / Kanji")
- (evil-test-buffer
- "1234漢[字]"
- ("ge")
- "123[4]漢字"))
- (ert-info ("numeric / Hiragana")
- (evil-test-buffer
- "1234ひらが[な]"
- ("ge")
- "123[4]ひらがな"))
- (ert-info ("numeric / Katakana")
- (evil-test-buffer
- "1234カタカ[ナ]"
- ("ge")
- "123[4]カタカナ"))
- (ert-info ("numeric / half-width Katakana")
- (evil-test-buffer
- "1234カタカ[ナ]"
- ("ge")
- "[1]234カタカナ"))
- (ert-info ("numeric / full-width alphabet")
- (evil-test-buffer
- "1234AB[C]"
- ("ge")
- "[1]234ABC"))
- (ert-info ("numeric / full-width numeric")
- (evil-test-buffer
- "123412[3]"
- ("ge")
- "[1]234123"))
- (ert-info ("numeric / Hangul")
- (evil-test-buffer
- "1234한[글]"
- ("ge")
- "123[4]한글"))
- (ert-info ("Kanji / Latin")
- (evil-test-buffer
- "漢字abc[d]"
- ("ge")
- "漢[字]abcd"))
- (ert-info ("Kanji / numeric")
- (evil-test-buffer
- "漢字123[4]"
- ("ge")
- "漢[字]1234"))
- (ert-info ("Kanji / Hiragana")
- (evil-test-buffer
- "漢字ひらが[な]"
- ("ge")
- "漢[字]ひらがな"))
- (ert-info ("Kanji / Katakana")
- (evil-test-buffer
- "漢字カタカ[ナ]"
- ("ge")
- "漢[字]カタカナ"))
- (ert-info ("Kanji / half-width Katakana")
- (evil-test-buffer
- "漢字カタカ[ナ]"
- ("ge")
- "漢[字]カタカナ"))
- (ert-info ("Kanji / full-width alphabet")
- (evil-test-buffer
- "漢字AB[C]"
- ("ge")
- "漢[字]ABC"))
- (ert-info ("Kanji / full-width numeric")
- (evil-test-buffer
- "漢字12[3]"
- ("ge")
- "漢[字]123"))
- (ert-info ("Kanji / Hangul")
- (evil-test-buffer
- "漢字한[글]"
- ("ge")
- "漢[字]한글"))
- (ert-info ("Hiragana / Latin")
- (evil-test-buffer
- "ひらがなabc[d]"
- ("ge")
- "ひらが[な]abcd"))
- (ert-info ("Hiragana / numeric")
- (evil-test-buffer
- "ひらがな123[4]"
- ("ge")
- "ひらが[な]1234"))
- (ert-info ("Hiragana / Kanji")
- (evil-test-buffer
- "ひらがな漢[字]"
- ("ge")
- "ひらが[な]漢字"))
- (ert-info ("Hiragana / Katakana")
- (evil-test-buffer
- "ひらがなカタカ[ナ]"
- ("ge")
- "ひらが[な]カタカナ"))
- (ert-info ("Hiragana / half-width Katakana")
- (evil-test-buffer
- "ひらがなカタカ[ナ]"
- ("ge")
- "ひらが[な]カタカナ"))
- (ert-info ("Hiragana / full-width alphabet")
- (evil-test-buffer
- "ひらがなAB[C]"
- ("ge")
- "ひらが[な]ABC"))
- (ert-info ("Hiragana / full-width numeric")
- (evil-test-buffer
- "ひらがな12[3]"
- ("ge")
- "ひらが[な]123"))
- (ert-info ("Hiragana / Hangul")
- (evil-test-buffer
- "ひらがな한[글]"
- ("ge")
- "ひらが[な]한글"))
- (ert-info ("Katakana / Latin")
- (evil-test-buffer
- "カタカナabc[d]"
- ("ge")
- "カタカ[ナ]abcd"))
- (ert-info ("Katakana / numeric")
- (evil-test-buffer
- "カタカナ123[4]"
- ("ge")
- "カタカ[ナ]1234"))
- (ert-info ("Katakana / Kanji")
- (evil-test-buffer
- "カタカナ漢[字]"
- ("ge")
- "カタカ[ナ]漢字"))
- (ert-info ("Katakana / Hiragana")
- (evil-test-buffer
- "カタカナひらが[な]"
- ("ge")
- "カタカ[ナ]ひらがな"))
- (ert-info ("Katakana / half-width Katakana")
- (evil-test-buffer
- "カタカナカタカ[ナ]"
- ("ge")
- "カタカ[ナ]カタカナ"))
- (ert-info ("Katakana / full-width alphabet")
- (evil-test-buffer
- "カタカナAB[C]"
- ("ge")
- "カタカ[ナ]ABC"))
- (ert-info ("Katakana / full-width numeric")
- (evil-test-buffer
- "カタカナ12[3]"
- ("ge")
- "カタカ[ナ]123"))
- (ert-info ("Katakana / Hangul")
- (evil-test-buffer
- "カタカナ한[글]"
- ("ge")
- "カタカ[ナ]한글"))
- (ert-info ("half-width Katakana / Latin")
- (evil-test-buffer
- "カタカナabc[d]"
- ("ge")
- "[カ]タカナabcd"))
- (ert-info ("half-width Katakana / numeric")
- (evil-test-buffer
- "カタカナ123[4]"
- ("ge")
- "[カ]タカナ1234"))
- (ert-info ("half-width Katakana / Kanji")
- (evil-test-buffer
- "カタカナ漢[字]"
- ("ge")
- "カタカ[ナ]漢字"))
- (ert-info ("half-width Katakana / Hiragana")
- (evil-test-buffer
- "カタカナひらが[な]"
- ("ge")
- "カタカ[ナ]ひらがな"))
- (ert-info ("half-width Katakana / Katakana")
- (evil-test-buffer
- "カタカナカタカ[ナ]"
- ("ge")
- "カタカ[ナ]カタカナ"))
- (ert-info ("half-width Katakana / full-width alphabet")
- (evil-test-buffer
- "カタカナAB[C]"
- ("ge")
- "[カ]タカナABC"))
- (ert-info ("half-width Katakana / full-width numeric")
- (evil-test-buffer
- "カタカナ12[3]"
- ("ge")
- "[カ]タカナ123"))
- (ert-info ("half-width Katakana / Hangul")
- (evil-test-buffer
- "カタカナ한[글]"
- ("ge")
- "カタカ[ナ]한글"))
- (ert-info ("full-width alphabet / Latin")
- (evil-test-buffer
- "ABCabc[d]"
- ("ge")
- "[A]BCabcd"))
- (ert-info ("full-width alphabet / numeric")
- (evil-test-buffer
- "ABC123[4]"
- ("ge")
- "[A]BC1234"))
- (ert-info ("full-width alphabet / Kanji")
- (evil-test-buffer
- "ABC漢[字]"
- ("ge")
- "AB[C]漢字"))
- (ert-info ("full-width alphabet / Hiragana")
- (evil-test-buffer
- "ABCひらが[な]"
- ("ge")
- "AB[C]ひらがな"))
- (ert-info ("full-width alphabet / Katakana")
- (evil-test-buffer
- "ABCカタカ[ナ]"
- ("ge")
- "AB[C]カタカナ"))
- (ert-info ("full-width alphabet / half-width Katakana")
- (evil-test-buffer
- "ABCカタカ[ナ]"
- ("ge")
- "[A]BCカタカナ"))
- (ert-info ("full-width alphabet / full-width numeric")
- (evil-test-buffer
- "ABC12[3]"
- ("ge")
- "[A]BC123"))
- (ert-info ("full-width alphabet / Hangul")
- (evil-test-buffer
- "ABC한[글]"
- ("ge")
- "AB[C]한글"))
- (ert-info ("full-width numeric / Latin")
- (evil-test-buffer
- "123abc[d]"
- ("ge")
- "[1]23abcd"))
- (ert-info ("full-width numeric / numeric")
- (evil-test-buffer
- "123123[4]"
- ("ge")
- "[1]231234"))
- (ert-info ("full-width numeric / Kanji")
- (evil-test-buffer
- "123漢[字]"
- ("ge")
- "12[3]漢字"))
- (ert-info ("full-width numeric / Hiragana")
- (evil-test-buffer
- "123ひらが[な]"
- ("ge")
- "12[3]ひらがな"))
- (ert-info ("full-width numeric / Katakana")
- (evil-test-buffer
- "123カタカ[ナ]"
- ("ge")
- "12[3]カタカナ"))
- (ert-info ("full-width numeric / half-width Katakana")
- (evil-test-buffer
- "123カタカ[ナ]"
- ("ge")
- "[1]23カタカナ"))
- (ert-info ("full-width numeric / full-width alphabet")
- (evil-test-buffer
- "123AB[C]"
- ("ge")
- "[1]23ABC"))
- (ert-info ("full-width numeric / Hangul")
- (evil-test-buffer
- "123한[글]"
- ("ge")
- "12[3]한글"))
- (ert-info ("Hangul / Latin")
- (evil-test-buffer
- "한글abc[d]"
- ("ge")
- "한[글]abcd"))
- (ert-info ("Hangul / numeric")
- (evil-test-buffer
- "한글123[4]"
- ("ge")
- "한[글]1234"))
- (ert-info ("Hangul / Kanji")
- (evil-test-buffer
- "한글漢[字]"
- ("ge")
- "한[글]漢字"))
- (ert-info ("Hangul / Hiragana")
- (evil-test-buffer
- "한글ひらが[な]"
- ("ge")
- "한[글]ひらがな"))
- (ert-info ("Hangul / Katakana")
- (evil-test-buffer
- "한글カタカ[ナ]"
- ("ge")
- "한[글]カタカナ"))
- (ert-info ("Hangul / half-width Katakana")
- (evil-test-buffer
- "한글カタカ[ナ]"
- ("ge")
- "한[글]カタカナ"))
- (ert-info ("Hangul / full-width alphabet")
- (evil-test-buffer
- "한글AB[C]"
- ("ge")
- "한[글]ABC"))
- (ert-info ("Hangul / full-width numeric")
- (evil-test-buffer
- "한글12[3]"
- ("ge")
- "한[글]123")))
-
-(ert-deftest evil-test-forward-paragraph ()
- "Test `evil-forward-paragraph'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[A]bove some line
-
-Below some empty line"
- ("}")
- "Above some line
-\[]
-Below some empty line"))
- (ert-info ("With count")
- (evil-test-buffer
- "[A]bove some line
-
-Below some empty line"
- ("2}")
- "Above some line
-
-Below some empty lin[e]"))
- (ert-info ("End of buffer")
- (evil-test-buffer
- "[B]elow some empty line"
- ("100}")
- "Below some empty lin[e]"
- (should-error (execute-kbd-macro "}"))
- (should-error (execute-kbd-macro "42}"))))
- (ert-info ("End of buffer with newline")
- (evil-test-buffer
- "[B]elow some empty line\n\n"
- ("100}")
- "Below some empty line\n\n[]"
- (should-error (execute-kbd-macro "}"))
- (should-error (execute-kbd-macro "42}")))))
-
-(ert-deftest evil-test-backward-paragraph ()
- "Test `evil-backward-paragraph'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "Above some line
-
-Below some empty lin[e]"
- ("{")
- "Above some line
-\[]
-Below some empty line"))
- (ert-info ("With count")
- (evil-test-buffer
- "Above some line
-
-Below some empty lin[e]"
- ("2{")
- "[A]bove some line
-
-Below some empty line"))
- (ert-info ("Beginning of buffer")
- (evil-test-buffer
- "Above some line
-
-Below some empty lin[e]"
- ("100{")
- "[A]bove some line
-
-Below some empty line"
- (should-error (execute-kbd-macro "{"))
- (should-error (execute-kbd-macro "42{"))))
- (ert-info ("Beginning of buffer with newlines")
- (evil-test-buffer
- "\n\nAbove some line
-
-Below some empty lin[e]"
- ("100{")
- "[]\n\nAbove some line
-
-Below some empty line"
- (should-error (execute-kbd-macro "{"))
- (should-error (execute-kbd-macro "42{")))))
-
-(ert-deftest evil-test-forward-sentence ()
- "Test `evil-forward-sentence'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."
- (")")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. [I]f you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."
- (")")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-\[]
-Below some empty line."
- (")")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-\[B]elow some empty line."))
- (ert-info ("With count")
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."
- ("2)")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-\[]
-Below some empty line."
- ("2)")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line[.]"))
- (ert-info ("End of buffer")
- (evil-test-buffer
- "[B]elow some empty line."
- ("100)")
- "Below some empty line[.]"
- (should-error (execute-kbd-macro ")"))
- (should-error (execute-kbd-macro "42)"))))
- (ert-info ("End of buffer with newline")
- (evil-test-buffer
- "[B]elow some empty line.\n\n"
- (")")
- "Below some empty line.\n[\n]"
- (")")
- "Below some empty line.\n\n[]"
- (should-error (execute-kbd-macro ")"))
- (should-error (execute-kbd-macro "42)")))))
-
-(ert-deftest evil-test-backward-sentence ()
- "Test `evil-backward-sentence'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line[.]"
- ("(")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-\[B]elow some empty line."
- ("(")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-\[]
-Below some empty line."
- ("(")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. [I]f you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."
- ("(")
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line[.]"
- ("2(")
- ";; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-\[]
-Below some empty line."
- ("2(")
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation. If you want to create a file,
-;; visit that file with C-x C-f.
-
-Below some empty line."))
- (ert-info ("Beginning of buffer")
- (evil-test-buffer
- ";; This buffer is for notes you don't want to save[.]"
- ("100(")
- "[;]; This buffer is for notes you don't want to save."
- (should-error (execute-kbd-macro "("))
- (should-error (execute-kbd-macro "42("))))
- (ert-info ("Beginning of buffer with newlines")
- (evil-test-buffer
- "\n\n;; This buffer is for notes you don't want to save[.]"
- ("100(")
- "[]\n\n;; This buffer is for notes you don't want to save."
- (should-error (execute-kbd-macro "("))
- (should-error (execute-kbd-macro "42(")))))
-
-(ert-deftest evil-test-find-char ()
- "Test `evil-find-char'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("fT")
- ";; [T]his buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("2fe")
- ";; This buffer is for not[e]s."))
- (ert-info ("Repeat")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("fe;")
- ";; This buffer is for not[e]s."))
- (ert-info ("Repeat backward")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("2fe,")
- ";; This buff[e]r is for notes."))
- (ert-info ("No match")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (should-error (execute-kbd-macro "fL"))))
- (ert-info ("End of line")
- (let ((evil-cross-lines t))
- (evil-test-buffer
- "[;]; This buffer is for notes,
-;; and for Lisp evaluation."
- ("fL")
- ";; This buffer is for notes,
-;; and for [L]isp evaluation."))))
-
-(ert-deftest evil-test-find-char-backward ()
- "Test `evil-find-char-backward'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("FT")
- ";; [T]his buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2Fe")
- ";; This buff[e]r is for notes."))
- (ert-info ("Repeat")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("Fe;")
- ";; This buff[e]r is for notes."))
- (ert-info ("Repeat backward")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2Fe,")
- ";; This buffer is for not[e]s."))
- (ert-info ("No match")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- (should-error (execute-kbd-macro "FL"))))
- (ert-info ("End of line")
- (let ((evil-cross-lines t))
- (evil-test-buffer
- ";; This buffer is for notes,
-;; and for Lisp evaluation[.]"
- ("FT")
- ";; [T]his buffer is for notes,
-;; and for Lisp evaluation."))))
-
-(ert-deftest evil-test-find-char-to ()
- "Test `evil-find-char-to'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("tT")
- ";;[ ]This buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("2te")
- ";; This buffer is for no[t]es."))
- (ert-info ("Repeat")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("tel;")
- ";; This buffer is for no[t]es."))
- (ert-info ("Repeat backward")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- ("2te,")
- ";; This buffe[r] is for notes."))
- (ert-info ("Repeat should skip adjacent character")
- (let ((evil-repeat-find-to-skip-next t))
- (evil-test-buffer
- "[a]aaxaaaxaaaxaaa"
- ("tx;")
- "aaaxaa[a]xaaaxaaa"
- (";")
- "aaaxaaaxaa[a]xaaa"
- (",")
- "aaaxaaax[a]aaxaaa"
- (",")
- "aaax[a]aaxaaaxaaa")))
- (ert-info ("Repeat should NOT skip adjacent character")
- (let ((evil-repeat-find-to-skip-next nil))
- (evil-test-buffer
- "[a]aaxaaaxaaaxaaa"
- ("tx;")
- "aa[a]xaaaxaaaxaaa")))
- (ert-info ("No match")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (should-error (execute-kbd-macro "tL"))))
- (ert-info ("End of line")
- (let ((evil-cross-lines t))
- (evil-test-buffer
- "[;]; This buffer is for notes,
-;; and for Lisp evaluation."
- ("tL")
- ";; This buffer is for notes,
-;; and for[ ]Lisp evaluation."))))
-
-(ert-deftest evil-test-find-char-to-backward ()
- "Test `evil-find-char-to-backward'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("TT")
- ";; T[h]is buffer is for notes."))
- (ert-info ("With count")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2Te")
- ";; This buffe[r] is for notes."))
- (ert-info ("Repeat")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("Teh;")
- ";; This buffe[r] is for notes."))
- (ert-info ("Repeat backward")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- ("2Te,")
- ";; This buffer is for no[t]es."))
- (ert-info ("Repeat should skip adjacent character")
- (let ((evil-repeat-find-to-skip-next t))
- (evil-test-buffer
- "aaaxaaaxaaaxaa[a]"
- ("Tx;")
- "aaaxaaax[a]aaxaaa"
- (";")
- "aaax[a]aaxaaaxaaa"
- (",")
- "aaaxaa[a]xaaaxaaa"
- (",")
- "aaaxaaaxaa[a]xaaa")))
- (ert-info ("Repeat should NOT skip adjacent character")
- (let ((evil-repeat-find-to-skip-next nil))
- (evil-test-buffer
- "aaaxaaaxaaaxaa[a]"
- ("Tx;")
- "aaaxaaaxaaax[a]aa")))
- (ert-info ("No match")
- (evil-test-buffer
- ";; This buffer is for notes[.]"
- (should-error (execute-kbd-macro "TL"))))
- (ert-info ("End of line")
- (let ((evil-cross-lines t))
- (evil-test-buffer
- ";; This buffer is for notes,
-;; and for Lisp evaluation[.]"
- ("TT")
- ";; T[h]is buffer is for notes,
-;; and for Lisp evaluation."))))
-
-(ert-deftest evil-test-jump-item ()
- "Test `evil-jump-item'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "int main[(]int argc, char** argv)"
- ("%")
- "int main(int argc, char** argv[)]"
- ("%")
- "int main[(]int argc, char** argv)"))
- (ert-info ("Before parenthesis")
- (evil-test-buffer
- "[i]nt main(int argc, char** argv)"
- ("%")
- "int main(int argc, char** argv[)]"
- ("5h")
- "int main(int argc, char**[ ]argv)"
- ("%")
- "int main[(]int argc, char** argv)"))
- (ert-info ("Over several lines")
- (evil-test-buffer
- "int main(int argc, char** argv)
-\[{]
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-}"
- ("%")
- "int main(int argc, char** argv)
-{
- printf(\"Hello world\\n\");
- return EXIT_SUCCESS;
-\[}]"))
- (ert-info ("On line without parenthesis")
- (evil-test-buffer
- "[#]include <stdio.h>"
- (should-error (execute-kbd-macro "%"))))
- (ert-info ("Before unmatched opening parenthesies")
- (evil-test-buffer
- "x[x]xx ( yyyyy () zzzz"
- (should-error (execute-kbd-macro "%"))
- "x[x]xx ( yyyyy () zzzz"))
- (ert-info ("Before unmatched closing parenthesies")
- (evil-test-buffer
- "x[x]xx ) yyyyy () zzzz"
- (should-error (execute-kbd-macro "%"))
- "x[x]xx ) yyyyy () zzzz"))
-
- (ert-info ("At the end of the line")
- (evil-test-buffer
- "[p]ublic void foo(String bar) {\n blabla;\n}\n"
- ("v$%")
- "public void foo(String bar) {\n blabla;\n[}]\n")))
-
-(ert-deftest evil-test-unmatched-paren ()
- "Test `evil-previous-open-paren' and `evil-next-close-paren'"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "foo ( { ( [b]ar ) baz } )"
- ("[(")
- "foo ( { [(] bar ) baz } )"
- ("])")
- "foo ( { ( bar [)] baz } )"
- ("[(")
- "foo ( { [(] bar ) baz } )"
- ("[(")
- "foo [(] { ( bar ) baz } )"
- ("f)])")
- "foo ( { ( bar ) baz } [)]"))
- (ert-info ("With count")
- (evil-test-buffer
- "foo ( { ( [b]ar ) baz } )"
- ("2[(")
- "foo [(] { ( bar ) baz } )")
- (evil-test-buffer
- "foo ( { ( [b]ar ) baz } )"
- ("2])")
- "foo ( { ( bar ) baz } [)]")))
-
-(ert-deftest evil-test-flyspell-motions ()
- "Test flyspell motions"
- :tags '(evil motion)
- (ert-info ("Simple")
- (evil-test-buffer
- "[I] cannt tpye for lyfe"
- (flyspell-mode)
- (flyspell-buffer)
- ("]s")
- "I [c]annt tpye for lyfe"
- ("]s")
- "I cannt [t]pye for lyfe"
- ("]s")
- "I cannt tpye for [l]yfe"
- ("]s")
- "I [c]annt tpye for lyfe"
- ("[s")
- "I cannt tpye for [l]yfe"
- ("[s")
- "I cannt [t]pye for lyfe"))
- (ert-info ("With count")
- (evil-test-buffer
- "[I] cannt tpye for lyfe"
- (flyspell-mode)
- (flyspell-buffer)
- ("2]s")
- "I cannt [t]pye for lyfe"
- ("2]s")
- "I [c]annt tpye for lyfe"
- ("2[s")
- "I cannt [t]pye for lyfe"
- ("2[s")
- "I cannt tpye for [l]yfe"))
- (ert-info ("With evil-search-wrap disabled")
- (let (evil-search-wrap)
- (evil-test-buffer
- "[I] cannt tpye for lyfe"
- (flyspell-mode)
- (flyspell-buffer)
- ("]s")
- "I [c]annt tpye for lyfe"
- ("]s")
- "I cannt [t]pye for lyfe"
- ("]s")
- "I cannt tpye for [l]yfe"
- ("]s")
- "I cannt tpye for [l]yfe")))
- (ert-info ("One mistake")
- (evil-test-buffer
- "[I]'m almst there..."
- (flyspell-mode)
- (flyspell-buffer)
- ("]s")
- "I'm [a]lmst there..."
- ("]s")
- "I'm [a]lmst there..."))
- (ert-info ("No mistakes")
- (evil-test-buffer
- "[I]'ve learned to type!"
- (flyspell-mode)
- (flyspell-buffer)
- ("]s")
- "[I]'ve learned to type!"
- ("[s")
- "[I]'ve learned to type!")))
-
-;;; Text objects
-
-(ert-deftest evil-test-text-object ()
- "Test `evil-define-text-object'"
- :tags '(evil text-object)
- (let ((object (evil-define-text-object nil (count &optional beg end type)
- (let ((sel (and beg end (evil-range beg end))))
- (when (and sel (> count 0)) (forward-char 1))
- (let ((range (if (< count 0)
- (list (- (point) 3) (point))
- (list (point) (+ (point) 3)))))
- (if sel
- (evil-range-union range sel)
- range))))))
- (ert-info ("Select three characters after point")
- (evil-test-buffer
- :state operator
- ";; [T]his buffer is for notes."
- (should (equal (funcall object 1) '(4 7 inclusive)))))
- (ert-info ("Select three characters before point")
- (evil-test-buffer
- :state operator
- ";; [T]his buffer is for notes."
- (should (equal (funcall object -1) '(1 4 inclusive)))))
- (ert-info ("Select three characters after selection")
- (evil-test-buffer
- ";; <Thi[s]> buffer is for notes."
- (call-interactively object)
- ";; <This b[u]>ffer is for notes."))
- (ert-info ("Select three characters before selection")
- (evil-test-buffer
- ";; <[T]his> buffer is for notes."
- (call-interactively object)
- "<[;]; This> buffer is for notes."))
- (ert-info ("Delete three characters after point")
- (evil-test-buffer
- "[;]; This buffer is for notes."
- (define-key evil-operator-state-local-map "io" object)
- ("dio")
- "[T]his buffer is for notes."))))
-
-(ert-deftest evil-test-word-objects ()
- "Test `evil-inner-word' and `evil-a-word'"
- :tags '(evil text-object)
- (ert-info ("Select a word")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("viw")
- ";; <Thi[s]> buffer is for notes.")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("vaw")
- ";; <This[ ]>buffer is for notes.")
- (evil-test-buffer
- ";; Thi[s] buffer is for notes."
- ("viw")
- ";; <Thi[s]> buffer is for notes.")
- (evil-test-buffer
- ";; Thi[s] buffer is for notes."
- ("vaw")
- ";; <This[ ]>buffer is for notes."))
- (ert-info ("Select two words")
- (ert-info ("Include whitespace on this side")
- (evil-test-buffer
- ";;< Thi[s]> buffer is for notes."
- ("aw")
- ";;< This buffe[r]> is for notes.")
- (evil-test-buffer
- ";; This <[b]uffer >is for notes."
- ("aw")
- ";; <[T]his buffer >is for notes."))
- (ert-info ("Include whitespace on the other side")
- (evil-test-buffer
- ";; <This[ ]>buffer is for notes."
- ("aw")
- ";; <This buffer[ ]>is for notes.")
- (evil-test-buffer
- ";; This<[ ]buffer> is for notes."
- ("aw")
- ";;<[ ]This buffer> is for notes.")))
- (ert-info ("select first visual word")
- (evil-test-buffer
- "([a])"
- ("viw")
- "(<[a]>)")))
-
-(ert-deftest evil-test-word-objects-cjk ()
- "Test `evil-inner-word' and `evil-a-word' on CJK words"
- :tags '(evil text-object cjk)
- (ert-info ("Select a word")
- (evil-test-buffer
- "[a]bcd1234"
- ("viw")
- "<abcd123[4]>")
- (evil-test-buffer
- "[a]bcd1234"
- ("vaw")
- "<abcd123[4]>")
- (evil-test-buffer
- "[a]bcd漢字"
- ("viw")
- "<abc[d]>漢字")
- (evil-test-buffer
- "[a]bcd漢字"
- ("vaw")
- "<abc[d]>漢字")
- (evil-test-buffer
- "[a]bcdひらがな"
- ("viw")
- "<abc[d]>ひらがな")
- (evil-test-buffer
- "[a]bcdひらがな"
- ("vaw")
- "<abc[d]>ひらがな")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("viw")
- "<abc[d]>カタカナ")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("vaw")
- "<abc[d]>カタカナ")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("viw")
- "<abcdカタカ[ナ]>")
- (evil-test-buffer
- "[a]bcdカタカナ"
- ("vaw")
- "<abcdカタカ[ナ]>")
- (evil-test-buffer
- "[a]bcdABC"
- ("viw")
- "<abcdAB[C]>")
- (evil-test-buffer
- "[a]bcdABC"
- ("vaw")
- "<abcdAB[C]>")
- (evil-test-buffer
- "[a]bcd123"
- ("viw")
- "<abcd12[3]>")
- (evil-test-buffer
- "[a]bcd123"
- ("vaw")
- "<abcd12[3]>")
- (evil-test-buffer
- "[a]bcd한글"
- ("viw")
- "<abc[d]>한글")
- (evil-test-buffer
- "[a]bcd한글"
- ("vaw")
- "<abc[d]>한글")
- (evil-test-buffer
- "[1]234abcd"
- ("viw")
- "<1234abc[d]>")
- (evil-test-buffer
- "[1]234abcd"
- ("vaw")
- "<1234abc[d]>")
- (evil-test-buffer
- "[1]234漢字"
- ("viw")
- "<123[4]>漢字")
- (evil-test-buffer
- "[1]234漢字"
- ("vaw")
- "<123[4]>漢字")
- (evil-test-buffer
- "[1]234ひらがな"
- ("viw")
- "<123[4]>ひらがな")
- (evil-test-buffer
- "[1]234ひらがな"
- ("vaw")
- "<123[4]>ひらがな")
- (evil-test-buffer
- "[1]234カタカナ"
- ("viw")
- "<123[4]>カタカナ")
- (evil-test-buffer
- "[1]234カタカナ"
- ("vaw")
- "<123[4]>カタカナ")
- (evil-test-buffer
- "[1]234カタカナ"
- ("viw")
- "<1234カタカ[ナ]>")
- (evil-test-buffer
- "[1]234カタカナ"
- ("vaw")
- "<1234カタカ[ナ]>")
- (evil-test-buffer
- "[1]234ABC"
- ("viw")
- "<1234AB[C]>")
- (evil-test-buffer
- "[1]234ABC"
- ("vaw")
- "<1234AB[C]>")
- (evil-test-buffer
- "[1]234123"
- ("viw")
- "<123412[3]>")
- (evil-test-buffer
- "[1]234123"
- ("vaw")
- "<123412[3]>")
- (evil-test-buffer
- "[1]234한글"
- ("viw")
- "<123[4]>한글")
- (evil-test-buffer
- "[1]234한글"
- ("vaw")
- "<123[4]>한글")
- (evil-test-buffer
- "[漢]字abcd"
- ("viw")
- "<漢[字]>abcd")
- (evil-test-buffer
- "[漢]字abcd"
- ("vaw")
- "<漢[字]>abcd")
- (evil-test-buffer
- "[漢]字1234"
- ("viw")
- "<漢[字]>1234")
- (evil-test-buffer
- "[漢]字1234"
- ("vaw")
- "<漢[字]>1234")
- (evil-test-buffer
- "[漢]字ひらがな"
- ("viw")
- "<漢[字]>ひらがな")
- (evil-test-buffer
- "[漢]字ひらがな"
- ("vaw")
- "<漢[字]>ひらがな")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("viw")
- "<漢[字]>カタカナ")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("vaw")
- "<漢[字]>カタカナ")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("viw")
- "<漢[字]>カタカナ")
- (evil-test-buffer
- "[漢]字カタカナ"
- ("vaw")
- "<漢[字]>カタカナ")
- (evil-test-buffer
- "[漢]字ABC"
- ("viw")
- "<漢[字]>ABC")
- (evil-test-buffer
- "[漢]字ABC"
- ("vaw")
- "<漢[字]>ABC")
- (evil-test-buffer
- "[漢]字123"
- ("viw")
- "<漢[字]>123")
- (evil-test-buffer
- "[漢]字123"
- ("vaw")
- "<漢[字]>123")
- (evil-test-buffer
- "[漢]字한글"
- ("viw")
- "<漢[字]>한글")
- (evil-test-buffer
- "[漢]字한글"
- ("vaw")
- "<漢[字]>한글")
- (evil-test-buffer
- "[ひ]らがなabcd"
- ("viw")
- "<ひらが[な]>abcd")
- (evil-test-buffer
- "[ひ]らがなabcd"
- ("vaw")
- "<ひらが[な]>abcd")
- (evil-test-buffer
- "[ひ]らがな1234"
- ("viw")
- "<ひらが[な]>1234")
- (evil-test-buffer
- "[ひ]らがな1234"
- ("vaw")
- "<ひらが[な]>1234")
- (evil-test-buffer
- "[ひ]らがな漢字"
- ("viw")
- "<ひらが[な]>漢字")
- (evil-test-buffer
- "[ひ]らがな漢字"
- ("vaw")
- "<ひらが[な]>漢字")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("viw")
- "<ひらが[な]>カタカナ")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("vaw")
- "<ひらが[な]>カタカナ")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("viw")
- "<ひらが[な]>カタカナ")
- (evil-test-buffer
- "[ひ]らがなカタカナ"
- ("vaw")
- "<ひらが[な]>カタカナ")
- (evil-test-buffer
- "[ひ]らがなABC"
- ("viw")
- "<ひらが[な]>ABC")
- (evil-test-buffer
- "[ひ]らがなABC"
- ("vaw")
- "<ひらが[な]>ABC")
- (evil-test-buffer
- "[ひ]らがな123"
- ("viw")
- "<ひらが[な]>123")
- (evil-test-buffer
- "[ひ]らがな123"
- ("vaw")
- "<ひらが[な]>123")
- (evil-test-buffer
- "[ひ]らがな한글"
- ("viw")
- "<ひらが[な]>한글")
- (evil-test-buffer
- "[ひ]らがな한글"
- ("vaw")
- "<ひらが[な]>한글")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("viw")
- "<カタカ[ナ]>abcd")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("vaw")
- "<カタカ[ナ]>abcd")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("viw")
- "<カタカ[ナ]>1234")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("vaw")
- "<カタカ[ナ]>1234")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("viw")
- "<カタカ[ナ]>漢字")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("vaw")
- "<カタカ[ナ]>漢字")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("viw")
- "<カタカ[ナ]>ひらがな")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("vaw")
- "<カタカ[ナ]>ひらがな")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("viw")
- "<カタカ[ナ]>カタカナ")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("vaw")
- "<カタカ[ナ]>カタカナ")
- (evil-test-buffer
- "[カ]タカナABC"
- ("viw")
- "<カタカ[ナ]>ABC")
- (evil-test-buffer
- "[カ]タカナABC"
- ("vaw")
- "<カタカ[ナ]>ABC")
- (evil-test-buffer
- "[カ]タカナ123"
- ("viw")
- "<カタカ[ナ]>123")
- (evil-test-buffer
- "[カ]タカナ123"
- ("vaw")
- "<カタカ[ナ]>123")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("viw")
- "<カタカ[ナ]>한글")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("vaw")
- "<カタカ[ナ]>한글")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("viw")
- "<カタカナabc[d]>")
- (evil-test-buffer
- "[カ]タカナabcd"
- ("vaw")
- "<カタカナabc[d]>")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("viw")
- "<カタカナ123[4]>")
- (evil-test-buffer
- "[カ]タカナ1234"
- ("vaw")
- "<カタカナ123[4]>")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("viw")
- "<カタカ[ナ]>漢字")
- (evil-test-buffer
- "[カ]タカナ漢字"
- ("vaw")
- "<カタカ[ナ]>漢字")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("viw")
- "<カタカ[ナ]>ひらがな")
- (evil-test-buffer
- "[カ]タカナひらがな"
- ("vaw")
- "<カタカ[ナ]>ひらがな")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("viw")
- "<カタカ[ナ]>カタカナ")
- (evil-test-buffer
- "[カ]タカナカタカナ"
- ("vaw")
- "<カタカ[ナ]>カタカナ")
- (evil-test-buffer
- "[カ]タカナABC"
- ("viw")
- "<カタカナAB[C]>")
- (evil-test-buffer
- "[カ]タカナABC"
- ("vaw")
- "<カタカナAB[C]>")
- (evil-test-buffer
- "[カ]タカナ123"
- ("viw")
- "<カタカナ12[3]>")
- (evil-test-buffer
- "[カ]タカナ123"
- ("vaw")
- "<カタカナ12[3]>")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("viw")
- "<カタカ[ナ]>한글")
- (evil-test-buffer
- "[カ]タカナ한글"
- ("vaw")
- "<カタカ[ナ]>한글")
- (evil-test-buffer
- "[A]BCabcd"
- ("viw")
- "<ABCabc[d]>")
- (evil-test-buffer
- "[A]BCabcd"
- ("vaw")
- "<ABCabc[d]>")
- (evil-test-buffer
- "[A]BC1234"
- ("viw")
- "<ABC123[4]>")
- (evil-test-buffer
- "[A]BC1234"
- ("vaw")
- "<ABC123[4]>")
- (evil-test-buffer
- "[A]BC漢字"
- ("viw")
- "<AB[C]>漢字")
- (evil-test-buffer
- "[A]BC漢字"
- ("vaw")
- "<AB[C]>漢字")
- (evil-test-buffer
- "[A]BCひらがな"
- ("viw")
- "<AB[C]>ひらがな")
- (evil-test-buffer
- "[A]BCひらがな"
- ("vaw")
- "<AB[C]>ひらがな")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("viw")
- "<AB[C]>カタカナ")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("vaw")
- "<AB[C]>カタカナ")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("viw")
- "<ABCカタカ[ナ]>")
- (evil-test-buffer
- "[A]BCカタカナ"
- ("vaw")
- "<ABCカタカ[ナ]>")
- (evil-test-buffer
- "[A]BC123"
- ("viw")
- "<ABC12[3]>")
- (evil-test-buffer
- "[A]BC123"
- ("vaw")
- "<ABC12[3]>")
- (evil-test-buffer
- "[A]BC한글"
- ("viw")
- "<AB[C]>한글")
- (evil-test-buffer
- "[A]BC한글"
- ("vaw")
- "<AB[C]>한글")
- (evil-test-buffer
- "[1]23abcd"
- ("viw")
- "<123abc[d]>")
- (evil-test-buffer
- "[1]23abcd"
- ("vaw")
- "<123abc[d]>")
- (evil-test-buffer
- "[1]231234"
- ("viw")
- "<123123[4]>")
- (evil-test-buffer
- "[1]231234"
- ("vaw")
- "<123123[4]>")
- (evil-test-buffer
- "[1]23漢字"
- ("viw")
- "<12[3]>漢字")
- (evil-test-buffer
- "[1]23漢字"
- ("vaw")
- "<12[3]>漢字")
- (evil-test-buffer
- "[1]23ひらがな"
- ("viw")
- "<12[3]>ひらがな")
- (evil-test-buffer
- "[1]23ひらがな"
- ("vaw")
- "<12[3]>ひらがな")
- (evil-test-buffer
- "[1]23カタカナ"
- ("viw")
- "<12[3]>カタカナ")
- (evil-test-buffer
- "[1]23カタカナ"
- ("vaw")
- "<12[3]>カタカナ")
- (evil-test-buffer
- "[1]23カタカナ"
- ("viw")
- "<123カタカ[ナ]>")
- (evil-test-buffer
- "[1]23カタカナ"
- ("vaw")
- "<123カタカ[ナ]>")
- (evil-test-buffer
- "[1]23ABC"
- ("viw")
- "<123AB[C]>")
- (evil-test-buffer
- "[1]23ABC"
- ("vaw")
- "<123AB[C]>")
- (evil-test-buffer
- "[1]23한글"
- ("viw")
- "<12[3]>한글")
- (evil-test-buffer
- "[1]23한글"
- ("vaw")
- "<12[3]>한글")
- (evil-test-buffer
- "[한]글abcd"
- ("viw")
- "<한[글]>abcd")
- (evil-test-buffer
- "[한]글abcd"
- ("vaw")
- "<한[글]>abcd")
- (evil-test-buffer
- "[한]글1234"
- ("viw")
- "<한[글]>1234")
- (evil-test-buffer
- "[한]글1234"
- ("vaw")
- "<한[글]>1234")
- (evil-test-buffer
- "[한]글漢字"
- ("viw")
- "<한[글]>漢字")
- (evil-test-buffer
- "[한]글漢字"
- ("vaw")
- "<한[글]>漢字")
- (evil-test-buffer
- "[한]글ひらがな"
- ("viw")
- "<한[글]>ひらがな")
- (evil-test-buffer
- "[한]글ひらがな"
- ("vaw")
- "<한[글]>ひらがな")
- (evil-test-buffer
- "[한]글カタカナ"
- ("viw")
- "<한[글]>カタカナ")
- (evil-test-buffer
- "[한]글カタカナ"
- ("vaw")
- "<한[글]>カタカナ")
- (evil-test-buffer
- "[한]글カタカナ"
- ("viw")
- "<한[글]>カタカナ")
- (evil-test-buffer
- "[한]글カタカナ"
- ("vaw")
- "<한[글]>カタカナ")
- (evil-test-buffer
- "[한]글ABC"
- ("viw")
- "<한[글]>ABC")
- (evil-test-buffer
- "[한]글ABC"
- ("vaw")
- "<한[글]>ABC")
- (evil-test-buffer
- "[한]글123"
- ("viw")
- "<한[글]>123")
- (evil-test-buffer
- "[한]글123"
- ("vaw")
- "<한[글]>123")))
-
-(ert-deftest evil-test-paragraph-objects ()
- "Test `evil-inner-paragraph' and `evil-a-paragraph'"
- :tags '(evil text-object)
- (ert-info ("Select a paragraph with point at beginning")
- (evil-test-buffer
- "[;]; This buffer is for notes,
-;; and for Lisp evaluation.
-
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vap")
- "<;; This buffer is for notes,
-;; and for Lisp evaluation.
-\[]\n>\
-;; This buffer is for notes,
-;; and for Lisp evaluation."))
- (ert-info ("Select a paragraph with point at last line")
- (evil-test-buffer
- ";; This buffer is for notes,
-\[;]; and for Lisp evaluation.
-
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vap")
- "<;; This buffer is for notes,
-;; and for Lisp evaluation.
-\[]\n>\
-;; This buffer is for notes,
-;; and for Lisp evaluation."))
- (ert-info ("Select a paragraph with point after paragraph")
- (evil-test-buffer
- ";; This buffer is for notes,
-;; and for Lisp evaluation.
-\[]
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vap")
- ";; This buffer is for notes,
-;; and for Lisp evaluation.
-<
-;; This buffer is for notes,
-;; and for Lisp evaluation[.]>"))
- (ert-info ("Select inner paragraph")
- (evil-test-buffer
- "[;]; This buffer is for notes,
-;; and for Lisp evaluation.
-
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vip")
- "<;; This buffer is for notes,
-;; and for Lisp evaluation.[]
->
-;; This buffer is for notes,
-;; and for Lisp evaluation.")
- (evil-test-buffer
- ";; This buffer is for notes,
-\[;]; and for Lisp evaluation.
-
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vip")
- "<;; This buffer is for notes,
-;; and for Lisp evaluation.[]
->
-;; This buffer is for notes,
-;; and for Lisp evaluation.")
- (evil-test-buffer
- ";; This buffer is for notes,
-;; and for Lisp evaluation.
-\[]
-;; This buffer is for notes,
-;; and for Lisp evaluation."
- ("vip")
- ";; This buffer is for notes,
-;; and for Lisp evaluation.
-<
-;; This buffer is for notes,
-;; and for Lisp evaluation[.]>")))
-
-(ert-deftest evil-test-quote-objects ()
- "Test `evil-inner-single-quote' and `evil-a-single-quote'"
- :tags '(evil text-object)
- (ert-info ("Select text inside of '...'")
- (evil-test-buffer
- "This is 'a [t]est' for quote objects."
- ("vi'")
- "This is '<a tes[t]>' for quote objects.")
- (evil-test-buffer
- "This is \"a '[t]est'\" for quote objects."
- ("vi'")
- "This is \"a '<tes[t]>'\" for quote objects."))
- (ert-info ("Select text including enclosing quotes")
- (evil-test-buffer
- "This is 'a [t]est' for quote objects."
- ("v2i'")
- "This is <'a test[']> for quote objects."))
- (ert-info ("Select text including enclosing quotes and following space")
- (evil-test-buffer
- "This is 'a [t]est' for quote objects."
- ("va'")
- "This is <'a test'[ ]>for quote objects."))
- (ert-info ("Select text including enclosing quotes and previous space")
- (evil-test-buffer
- "This is 'a [t]est'. For quote objects."
- ("va'")
- "This is< 'a test[']>. For quote objects."))
- (ert-info ("Select text on opening quote")
- (evil-test-buffer
- "This is [\"]a test\". For \"quote\" objects."
- (emacs-lisp-mode)
- ("va\"")
- "This is< \"a test[\"]>. For \"quote\" objects."))
- (ert-info ("Select text on closing quote")
- (evil-test-buffer
- "This is \"a test[\"]. For \"quote\" objects."
- (emacs-lisp-mode)
- ("va\"")
- "This is< \"a test[\"]>. For \"quote\" objects."))
- (ert-info ("Delete text from outside")
- (evil-test-buffer
- "Th[i]s is \"a test\". For \"quote\" objects."
- (emacs-lisp-mode)
- ("da\"")
- "This is[.] For \"quote\" objects."))
- (ert-info ("Operator on empty quotes")
- (evil-test-buffer
- "This is [a]n \"\" empty quote"
- (emacs-lisp-mode)
- ("ci\"XXX" [escape])
- "This is an \"XX[X]\" empty quote")))
-
-(ert-deftest evil-test-paren-objects ()
- "Test `evil-inner-paren', etc."
- :tags '(evil text-object)
- (ert-info ("Select inner text")
- (evil-test-buffer
- "[(]aaa)"
- (emacs-lisp-mode) ; syntax
- ("vi(")
- "(<aa[a]>)")
- (evil-test-buffer
- "(aaa[)]"
- (emacs-lisp-mode)
- ("vi(")
- "(<aa[a]>)")
- (ert-info ("Next to outer delimiter")
- (evil-test-buffer
- "([(]aaa))"
- (emacs-lisp-mode)
- ("vi(")
- "((<aa[a]>))")
- (evil-test-buffer
- "((aaa[)])"
- (emacs-lisp-mode)
- ("vi(")
- "((<aa[a]>))")))
- (ert-info ("Select double inner parentheses")
- (evil-test-buffer
- "([(]word))"
- ("dib")
- "(())")
- (evil-test-buffer
- "[(](word))"
- ("dib")
- "()")
- (evil-test-buffer
- "((word[)])"
- ("dib")
- "(())")
- (evil-test-buffer
- "((word)[)]"
- ("dib")
- "()"))
- (ert-info ("Select double outer parentheses")
- (evil-test-buffer
- "a([(]word))b"
- ("dab")
- "a()b")
- (evil-test-buffer
- "a[(](word))b"
- ("dab")
- "ab")
- (evil-test-buffer
- "a((word[)])b"
- ("dab")
- "a()b")
- (evil-test-buffer
- "a((word)[)]b"
- ("dab")
- "ab"))
- (ert-info ("Select parentheses inside strings")
- (evil-test-buffer
- "(aaa \"b(b[b]b)\" aa)"
- (emacs-lisp-mode)
- ("va(")
- "(aaa \"b<(bbb[)]>\" aa)"))
- (ert-info ("Break out of empty strings")
- (evil-test-buffer
- "(aaa \"bb[b]b\" aa)"
- (emacs-lisp-mode)
- ("va(")
- "<(aaa \"bbbb\" aa[)]>"))
- (ert-info ("Select inner parentheses around strings")
- (evil-test-buffer
- "((\"t[e]st\"))\n"
- (emacs-lisp-mode)
- ("vib")
- "((<\"test[\"]>))\n"
- ("ib")
- "(<(\"test\"[)]>)\n")
- (evil-test-buffer
- "( ( \"t[e]st\" ) )\n"
- (emacs-lisp-mode)
- ("vib")
- "( (< \"test\"[ ]>) )\n"
- ("ib")
- "(< ( \"test\" )[ ]>)\n")
- (evil-test-buffer
- "((\"t[e]st\"))\n"
- (emacs-lisp-mode)
- ("vhhib")
- "((<[\"]test\">))\n"
- ("ib")
- "(<[(]\"test\")>)\n")
- (evil-test-buffer
- "( ( \"t[e]st\" ) )\n"
- (emacs-lisp-mode)
- ("vhhib")
- "( (<[ ]\"test\" >) )\n"
- ("ib")
- "(<[ ]( \"test\" ) >)\n"))
- (ert-info ("Select outer parentheses around strings")
- (evil-test-buffer
- "((\"t[e]st\"))\n"
- (emacs-lisp-mode)
- ("vab")
- "(<(\"test\"[)]>)\n"
- ("ab")
- "<((\"test\")[)]>\n")
- (evil-test-buffer
- "( ( \"t[e]st\" ) )\n"
- (emacs-lisp-mode)
- ("vab")
- "( <( \"test\" [)]> )\n"
- ("ab")
- "<( ( \"test\" ) [)]>\n")
- (evil-test-buffer
- "((\"t[e]st\"))\n"
- (emacs-lisp-mode)
- ("vhhab")
- "(<[(]\"test\")>)\n"
- ("ab")
- "<[(](\"test\"))>\n")
- (evil-test-buffer
- "( ( \"t[e]st\" ) )\n"
- (emacs-lisp-mode)
- ("vhhab")
- "( <[(] \"test\" )> )\n"
- ("ab")
- "<[(] ( \"test\" ) )>\n")
- (evil-test-buffer
- "(([\"]\"))\n"
- ("dab")
- "([)]\n"))
- (ert-info ("Select inner paren on different lines")
- (evil-test-buffer
- "for (auto i : vector) {
- if (cond) {
- do_[s]omething();
- }
-}"
- ("vi}")
- "for (auto i : vector) {
- if (cond) {
-< do_something();[\n]> }\n}"
- ("i}")
- "for (auto i : vector) {
-< if (cond) {
- do_something();
- }[\n]>}"))
- (ert-info ("Enlarge to smallest complete surrounding")
- (evil-test-buffer
- "for (auto i : vector) {
- if (c<ond) {
- do_[s]>omething();
- }
-}"
- ("i}")
- "for (auto i : vector) {
-< if (cond) {
- do_something();
- }[\n]>}"))
- (ert-info ("yank on blocks is turned linewise")
- (evil-test-buffer
- "{\n [f]oo();\n}\n"
- ("yiBp")
- "{\n foo();\n [f]oo();\n}\n"))
- (ert-info ("exclusive like if ending at bol")
- (evil-test-buffer
- "(defun foo ()\n[ ] (insert \"bar\")\n )\n"
- ("cibx" [escape])
- "([x]\n )\n"))
- (ert-info ("Operator on empty parentheses")
- (evil-test-buffer
- "a([(]))b"
- ("cibx" [escape])
- "a(([x]))b")
- (evil-test-buffer
- "a(([)])b"
- ("cibx" [escape])
- "a(([x]))b")))
-
-(ert-deftest evil-test-forces-linewise-text-objects ()
- "Test `evil-text-object-change-visual-type' option."
- :tags '(evil text-object)
- (let ((evil-text-object-change-visual-type t))
- (ert-info ("Change visual type")
- (evil-test-buffer
- " function(opts) {
- this.var1 = something();
- [t]his.var2 = something_else();
- return something_nasty();
- }
-"
- ("Vi}")
- " function(opts) {
-< this.var1 = something();
- this.var2 = something_else();
- return something_nasty();[
-]> }
-"
- (should (eq (evil-visual-type) 'inclusive)))))
- (let ((evil-text-object-change-visual-type nil))
- (ert-info ("Change visual type keeping linewise")
- (evil-test-buffer
- " function(opts) {
- this.var1 = something();
- [t]his.var2 = something_else();
- return something_nasty();
- }
-"
- ("Vi}")
- " function(opts) {
-< this.var1 = something();
- this.var2 = something_else();
- return something_nasty();\n> }
-"
- (should (eq (evil-visual-type) 'line)))))
- (let ((evil-text-object-change-visual-type nil))
- (ert-info ("Linewise outer block")
- (evil-test-buffer
- " function(opts) {
- this.var1 = something();
- [t]his.var2 = something_else();
- return something_nasty();
- }
-"
- ("Va}")
- "< function(opts) {
- this.var1 = something();
- this.var2 = something_else();
- return something_nasty();
- }
->"
- (should (eq (evil-visual-type) 'line)))))
- (ert-info ("Forced motion type should change text object type")
- (evil-test-buffer
- "for (int i=0; i<10; i++) {
- if ([c]ond) {
- do_something();
- }
-}"
- ("dVi}")
- "for (int i=0; i<10; i++) {
-\[}]")))
-
-(ert-deftest evil-test-tag-objects ()
- "Test `evil-inner-tag', etc."
- :tags '(evil text-object)
- (ert-info ("Handle nested tags")
- (evil-test-buffer
- :visual-start "{"
- :visual-end "}"
- "<p><a>f[o]o</a> bar</p>"
- ("vit")
- "<p><a>{fo[o]}</a> bar</p>"))
- (ert-info ("Break out of tags")
- (evil-test-buffer
- :visual-start "{"
- :visual-end "}"
- "<a[a]a>bbbb</aaa>"
- ("vit")
- "<aaa>{bbb[b]}</aaa>")
- (evil-test-buffer
- :visual-start "{"
- :visual-end "}"
- "<a[a]a>bbbb</aaa>"
- ("vat")
- "{<aaa>bbbb</aaa[>]}"))
- (ert-info ("Handle quoted strings tags")
- (evil-test-buffer
- :visual-start "{"
- :visual-end "}"
- "<html>
-<body>
-<div id=\"content\">
-\[ ]
-<p>
-UPDATE
-</p>
-<p>
-test hello <a href=\"/deed.zh\">Creative Commons</a>
-</p>
-</div>
-</body>
-</html>
-"
- ("vit")
- "<html>
-<body>
-<div id=\"content\">{\n \n<p>
-UPDATE
-</p>
-<p>
-test hello <a href=\"/deed.zh\">Creative Commons</a>
-</p>[\n]}</div>
-</body>
-</html>
-"
-
- )))
-
-;;; Visual state
-
-(defun evil-test-visual-select (selection &optional mark point)
- "Verify that TYPE is selected correctly"
- (let ((type (evil-visual-type selection)))
- (evil-visual-make-selection mark point type)
- (ert-info ("Activate region unless SELECTION is `block'")
- (cond
- ((eq selection 'block)
- (should (mark t))
- (should-not (region-active-p))
- (should-not transient-mark-mode))
- (t
- (should (mark))
- (should (region-active-p)))))
- (ert-info ("Refresh Visual markers")
- (should (= (evil-range-beginning (evil-expand (point) (mark) type))
- evil-visual-beginning))
- (should (= (evil-range-end (evil-expand (point) (mark) type))
- evil-visual-end))
- (should (eq (evil-visual-type) type))
- (should (eq evil-visual-direction
- (if (< (point) (mark)) -1 1))))))
-
-(ert-deftest evil-test-visual-refresh ()
- "Test `evil-visual-refresh'"
- :tags '(evil visual)
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (evil-visual-refresh nil nil 'inclusive)
- (should (= evil-visual-beginning 4))
- (should (= evil-visual-end 5)))
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- (let ((evil-visual-region-expanded t))
- (evil-visual-refresh nil nil 'inclusive)
- (should (= evil-visual-beginning 4))
- (should (= evil-visual-end 4)))))
-
-(ert-deftest evil-test-visual-exchange ()
- "Test `exchange-point-and-mark' in Visual character selection"
- :tags '(evil visual)
- (evil-test-buffer
- ";; <[T]his> buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("o")
- (should (region-active-p))
- ";; <Thi[s]> buffer is for notes you don't want to save,
-;; and for Lisp evaluation."))
-
-(ert-deftest evil-test-visual-char ()
- "Test Visual character selection"
- :tags '(evil visual)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- (evil-test-visual-select 'char)
- ";; <[T]>his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("e")
- ";; <Thi[s]> buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("o")
- ";; <[T]his> buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("d")
- ";; [ ]buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- ("vV")
- "<;; [ ]buffer is for notes you don't want to save,\n>\
-;; and for Lisp evaluation.")
- (ert-info ("Test `evil-want-visual-char-semi-exclusive")
- (let ((evil-want-visual-char-semi-exclusive t))
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; And a third line."
- ("v")
- "<[;]>; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.
-;; And a third line."
- ("$")
- "<;; This buffer is for notes you don't want to save,>[
-];; and for Lisp evaluation.
-;; And a third line."
- ("^jj")
- "<;; This buffer is for notes you don't want to save,
-;; and for Lisp evaluation.\n>[;]; And a third line."))))
-
-(ert-deftest evil-test-visual-line ()
- "Test Visual line selection"
- :tags '(evil visual)
- (evil-test-buffer
- ";; [T]his buffer is for notes you don't want to save,
-;; and for Lisp evaluation."
- (evil-test-visual-select 'line)
- "<;; [T]his buffer is for notes you don't want to save,\n>\
-;; and for Lisp evaluation."
- ("e")
- "<;; Thi[s] buffer is for notes you don't want to save,\n>\
-;; and for Lisp evaluation."
- ("o")
- "<;; [T]his buffer is for notes you don't want to save,\n>\
-;; and for Lisp evaluation."
- ("d")
- "[;]; and for Lisp evaluation."))
-
-(ert-deftest evil-test-visual-block ()
- "Test Visual block selection"
- :tags '(evil visual)
- (evil-test-buffer
- "[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- (evil-test-visual-select 'block)
- "<[;]>; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; then enter the text in that file's own buffer."
- ("jjll")
- "<;; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;;[ ]>then enter the text in that file's own buffer."
- ("O")
- ";; <This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
->[;]; then enter the text in that file's own buffer."
- ("o")
- ";;[ ]<This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
->;; then enter the text in that file's own buffer."
- ("O")
- "<[;]; This buffer is for notes you don't want to save.
-;; If you want to create a file, visit that file with C-x C-f,
-;; >then enter the text in that file's own buffer."
- ("d")
- "This buffer is for notes you don't want to save.
-If you want to create a file, visit that file with C-x C-f,
-then enter the text in that file's own buffer."))
-
-(ert-deftest evil-test-visual-restore ()
- "Test restoring a previous selection"
- :tags '(evil visual)
- (ert-info ("Start a characterwise selection \
-if no previous selection")
- (evil-test-buffer
- ";; [T]his buffer is for notes."
- ("gv")
- ";; <[T]>his buffer is for notes."))
- (ert-info ("Restore characterwise selection")
- (evil-test-buffer
- ";; <[T]his> buffer is for notes."
- ([escape] "gv")
- ";; <[T]his> buffer is for notes."))
- (ert-info ("Restore linewise selection")
- (evil-test-buffer
- :visual line
- "<;; [T]his buffer is for notes.>"
- ([escape] "gv")
- "<;; [T]his buffer is for notes.>"))
- (ert-info ("Restore blockwise selection")
- (evil-test-buffer
- :visual block
- "<;; This buffer is for notes,
-;;[ ]>and for Lisp evaluation."
- ([escape] "gv")
- "<;; This buffer is for notes,
-;;[ ]>and for Lisp evaluation.")))
-
-;;; Replace state
-
-(ert-deftest evil-test-replacement ()
- "Test replacing consecutive characters"
- :tags '(evil replace)
- (ert-info ("Replace and restore consecutive characters")
- (evil-test-buffer
- ";; [T]his buffer is for notes"
- ("Rfoo")
- ";; foo[s] buffer is for notes"
- ([backspace backspace backspace])
- ";; [T]his buffer is for notes"))
- (ert-info ("Replace and restore consecutive characters beyond eol")
- (evil-test-buffer
- ";; [T]his buffer is for notes"
- ("wwwwRxxxxxxx")
- ";; This buffer is for xxxxxxx[]"
- ([backspace backspace backspace backspace backspace backspace backspace])
- ";; This buffer is for [n]otes"))
- (ert-info ("Replace from line below and restore")
- (define-key evil-replace-state-map (kbd "C-e") 'evil-copy-from-below)
- (evil-test-buffer
- ";; [f]oo bar\n;; qux quux"
- ("R\C-e\C-e\C-e")
- ";; qux[ ]bar\n;; qux quux"
- ([backspace backspace backspace])
- ";; [f]oo bar\n;; qux quux")
- (define-key evil-replace-state-map (kbd "C-e") nil))
- (ert-info ("Replace from line above and restore")
- (define-key evil-replace-state-map (kbd "C-y") 'evil-copy-from-above)
- (evil-test-buffer
- ";; foo bar\n;; [q]ux quux"
- ("R\C-y\C-y\C-y")
- ";; foo bar\n;; foo[ ]quux"
- ([backspace backspace backspace])
- ";; foo bar\n;; [q]ux quux")
- (define-key evil-replace-state-map (kbd "C-y") nil)))
-
-;;; Ex
-
-(ert-deftest evil-test-ex-parse ()
- "Test `evil-ex-parse'"
- :tags '(evil ex)
- (should (equal (evil-ex-parse "5,2cmd arg")
- '(evil-ex-call-command
- (evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (string-to-number "2") nil))
- "cmd"
- "arg")))
- (should (equal (evil-ex-parse "5,2cmd !arg")
- '(evil-ex-call-command
- (evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (string-to-number "2") nil))
- "cmd"
- "!arg")))
- (should (equal (evil-ex-parse "5,2 arg")
- '(evil-ex-call-command
- (evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (string-to-number "2") nil))
- "arg"
- nil))))
-
-(ert-deftest evil-test-ex-parse-ranges ()
- "Test parsing of ranges"
- :tags '(evil ex)
- (should (equal (evil-ex-parse "%" nil 'range)
- '(evil-ex-full-range)))
- (should (equal (evil-ex-parse "5,27" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (string-to-number "27") nil))))
- (should (equal (evil-ex-parse "5,$" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (evil-ex-last-line) nil))))
- (should (equal (evil-ex-parse "5,'x" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line (evil-ex-marker "x") nil))))
- (should (equal (evil-ex-parse "`x,`y" nil 'range)
- '(evil-ex-char-marker-range "x" "y")))
- (should (equal (evil-ex-parse "5,+" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line
- nil (+ (evil-ex-signed-number (intern "+") nil))))))
- (should (equal (evil-ex-parse "5,-" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line
- nil (+ (evil-ex-signed-number (intern "-") nil))))))
- (should (equal (evil-ex-parse "5,4+2-7-3+10-" nil 'range)
- '(evil-ex-range
- (evil-ex-line (string-to-number "5") nil)
- (evil-ex-line
- (string-to-number "4")
- (+ (evil-ex-signed-number
- (intern "+") (string-to-number "2"))
- (evil-ex-signed-number
- (intern "-") (string-to-number "7"))
- (evil-ex-signed-number
- (intern "-") (string-to-number "3"))
- (evil-ex-signed-number
- (intern "+") (string-to-number "10"))
- (evil-ex-signed-number (intern "-") nil))))))
- (should (equal (evil-ex-parse ".-2,4+2-7-3+10-" nil 'range)
- '(evil-ex-range
- (evil-ex-line
- (evil-ex-current-line)
- (+ (evil-ex-signed-number
- (intern "-") (string-to-number "2"))))
- (evil-ex-line
- (string-to-number "4")
- (+ (evil-ex-signed-number
- (intern "+") (string-to-number "2"))
- (evil-ex-signed-number
- (intern "-") (string-to-number "7"))
- (evil-ex-signed-number
- (intern "-") (string-to-number "3"))
- (evil-ex-signed-number
- (intern "+") (string-to-number "10"))
- (evil-ex-signed-number
- (intern "-") nil))))))
- (should (equal (evil-ex-parse "'a-2,$-10" nil 'range)
- '(evil-ex-range
- (evil-ex-line
- (evil-ex-marker "a")
- (+ (evil-ex-signed-number
- (intern "-") (string-to-number "2"))))
- (evil-ex-line
- (evil-ex-last-line)
- (+ (evil-ex-signed-number
- (intern "-") (string-to-number "10")))))))
- (should (equal (evil-ex-parse ".+42" nil 'range)
- '(evil-ex-range
- (evil-ex-line
- (evil-ex-current-line)
- (+ (evil-ex-signed-number
- (intern "+") (string-to-number "42"))))
- nil))))
-
-(ert-deftest evil-test-ex-parse-emacs-commands ()
- "Test parsing of Emacs commands"
- :tags '(evil ex)
- (should (equal (evil-ex-parse "ido-mode")
- '(evil-ex-call-command nil "ido-mode" nil)))
- (should (equal (evil-ex-parse "yas/reload-all")
- '(evil-ex-call-command nil "yas/reload-all" nil)))
- (should (equal (evil-ex-parse "mu4e")
- '(evil-ex-call-command nil "mu4e" nil))))
-
-(ert-deftest evil-text-ex-search-offset ()
- "Test for addresses like /base//pattern/"
- :tags '(evil ex)
- (ert-info ("without base")
- (evil-test-buffer
- "[l]ine 1\naaa\nbbb\naaa\nccc\nddd"
- (":/aaa/d")
- "line 1\nbbb\naaa\nccc\nddd"))
- (ert-info ("with base")
- (evil-test-buffer
- "[l]ine 1\naaa\nbbb\naaa\nccc\nddd"
- (":/bbb//aaa/d")
- "line 1\naaa\nbbb\nccc\nddd"))
- (ert-info ("range without base")
- (evil-test-buffer
- "[l]ine 1\naaa\nbbb\naaa\nccc\nddd\nccc\neee\n"
- (":/aaa/;/ccc/d")
- "line 1\nddd\nccc\neee\n"))
- (ert-info ("range with base")
- (evil-test-buffer
- "[l]ine 1\naaa\nbbb\naaa\nccc\nddd\nccc\neee\n"
- (":/bbb//aaa/;/ddd//ccc/d")
- "line 1\naaa\nbbb\neee\n")))
-
-(ert-deftest evil-test-ex-goto-line ()
- "Test if :number moves point to a certain line"
- :tags '(evil ex)
- (ert-info ("Move to line")
- (evil-test-buffer
- :visual line
- "1\n 2\n [ ]3\n 4\n 5\n"
- (":4" [return])
- "1\n 2\n 3\n [4]\n 5\n"
- (":2" [return])
- "1\n [2]\n 3\n 4\n 5\n")))
-
-(ert-deftest evil-test-ex-repeat ()
- "Test :@: command."
- :tags '(evil ex)
- (evil-without-display
- (ert-info ("Repeat in current line")
- (evil-test-buffer
- "[a]bcdef\nabcdef\nabcdef"
- (":s/[be]/X/g" [return])
- "[a]XcdXf\nabcdef\nabcdef"
- ("jj:@:" [return])
- "aXcdXf\nabcdef\n[a]XcdXf"))
- (ert-info ("Repeat in specified line")
- (evil-test-buffer
- "[a]bcdef\nabcdef\nabcdef"
- (":s/[be]/X/g" [return])
- "[a]XcdXf\nabcdef\nabcdef"
- (":3@:" [return])
- "aXcdXf\nabcdef\n[a]XcdXf"))
- (ert-info ("Double repeat, first without then with specified line")
- (evil-test-buffer
- "[a]bcdef\nabcdef\nabcdef"
- (":s/[be]/X/" [return])
- "[a]Xcdef\nabcdef\nabcdef"
- ("jj:@:" [return] ":1@:" [return])
- "[a]XcdXf\nabcdef\naXcdef"))))
-
-(ert-deftest evil-test-ex-repeat2 ()
- "Test @: command."
- :tags '(evil ex)
- (evil-without-display
- (ert-info ("Repeat in current line")
- (evil-test-buffer
- "[a]bcdef\nabcdef\nabcdef"
- (":s/[be]/X" [return])
- "[a]Xcdef\nabcdef\nabcdef"
- ("jj@:")
- "aXcdef\nabcdef\n[a]Xcdef"))
- (ert-info ("Repeat with count in current line")
- (evil-test-buffer
- "[a]bcdef\nabcdef\nabcdef"
- (":s/[be]/X" [return])
- "[a]Xcdef\nabcdef\nabcdef"
- ("jj2@:")
- "aXcdef\nabcdef\n[a]XcdXf"))
- (ert-info ("Do not record dot repeat")
- (evil-test-buffer
- ""
- ("OAAAAAA" [escape] "^")
- "[A]AAAAA\n"
- (":s/A/X" [return])
- "[X]AAAAA\n"
- ("@:")
- "[X]XAAAA\n"
- (".")
- "AAAAAA\nXXAAAA\n"))))
-
-(ert-deftest evil-test-ex-visual-char-range ()
- "Test visual character ranges in ex state."
- :tags '(evil ex visual)
- (evil-without-display
- (ert-info ("No character range, inclusive")
- (let ((evil-visual-char 'inclusive)
- evil-ex-visual-char-range)
- (evil-test-buffer
- "li[n]e 1\nline 2\nline 3\nline 4\n"
- ("vjll:d" [return])
- "line 3\nline 4\n")))
- (ert-info ("No character range, exclusive")
- (let ((evil-visual-char 'inclusive)
- evil-ex-visual-char-range)
- (evil-test-buffer
- "li[n]e 1\nline 2\nline 3\nline 4\n"
- ("vjll:d" [return])
- "line 3\nline 4\n")))
- (ert-info ("Character range, inclusive")
- (let ((evil-visual-char 'inclusive)
- (evil-ex-visual-char-range t))
- (evil-test-buffer
- "li[n]e 1\nline 2\nline 3\nline 4\n"
- ("vjll:d" [return])
- "li2\nline 3\nline 4\n")))
- (ert-info ("Character range, exclusive")
- (let ((evil-visual-char 'exclusive)
- (evil-ex-visual-char-range t))
- (evil-test-buffer
- "li[n]e 1\nline 2\nline 3\nline 4\n"
- ("vjll:d" [return])
- "li 2\nline 3\nline 4\n")))))
-
-(ert-deftest evil-test-ex-substitute-replacement ()
- "Test `evil-ex-substitute' with special replacements."
- :tags '(evil ex search)
- (ert-info ("Substitute upper first on first match in line")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/\\(foo\\|bar\\)/\\u\\1" [return])
- "[x]xx Foo bar foo bar foo bar"))
- (ert-info ("Substitute upper first on first match in line with confirm")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/\\(foo\\|bar\\)/\\u\\1/c" [return] "y")
- "[x]xx Foo bar foo bar foo bar"))
- (ert-info ("Substitute upper first on whole line")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/\\(foo\\|bar\\)/\\u\\1/g" [return])
- "[x]xx Foo Bar Foo Bar Foo Bar"))
- (ert-info ("Substitute upper first on whole line")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/\\(foo\\|bar\\)/\\u\\1/gc" [return] "yynyyn")
- "[x]xx Foo Bar foo Bar Foo bar"))
- (ert-info ("Substitute upper/lower on first match in line")
- (evil-test-buffer
- "[x]xx foo BAR foo BAR foo BAR"
- (":s/\\(f[[:alpha:]]*\\>\\)\\s-*\\(b[[:alpha:]]*\\>\\)/\\L\\2_\\e\\U\\1"
[return])
- "[x]xx bar_FOO foo BAR foo BAR"))
- (ert-info ("Substitute upper/lower on first match in line with confirm")
- (evil-test-buffer
- "[x]xx foo BAR foo BAR foo BAR"
-
(":s/\\(f[[:alpha:]]*\\>\\)\\s-*\\(b[[:alpha:]]*\\>\\)/\\L\\2_\\e\\U\\1/c"
[return] "y")
- "[x]xx bar_FOO foo BAR foo BAR"))
- (ert-info ("Substitute upper/lower on whole line")
- (evil-test-buffer
- "[x]xx foo BAR foo BAR foo BAR"
-
(":s/\\(f[[:alpha:]]*\\>\\)\\s-*\\(b[[:alpha:]]*\\>\\)/\\L\\2_\\e\\U\\1/g"
[return])
- "[x]xx bar_FOO bar_FOO bar_FOO"))
- (ert-info ("Substitute upper/lower on whole line")
- (evil-test-buffer
- "[x]xx foo BAR foo BAR foo BAR"
-
(":s/\\(f[[:alpha:]]*\\>\\)\\s-*\\(b[[:alpha:]]*\\>\\)/\\L\\2_\\e\\U\\1/gc"
[return] "yny")
- "[x]xx bar_FOO foo BAR bar_FOO"))
- (ert-info ("Substitute with escaped characters in replacement")
- (evil-test-buffer
- "[a]bcXdefXghiXjkl\n"
- (":s/X/\\|\\/\\|/g" [return])
- "[a]bc|/|def|/|ghi|/|jkl\n"))
- (ert-info ("Substitute with register")
- (evil-test-buffer
- "[a]bc\niiiXiiiXiiiXiii\n"
- ("\"ayiwj:s/X/\\=@a/g" [return])
- "abc\n[i]iiabciiiabciiiabciii\n"))
- (ert-info ("Substitute newlines")
- (evil-test-buffer
- "[a]bc\ndef\nghi\n"
- (":%s/\n/z/" [return])
- "[a]bczdefzghiz"))
- (ert-info ("Substitute newlines with g flag")
- (evil-test-buffer
- "[a]bc\ndef\nghi\n"
- (":%s/\n/z/g" [return])
- "[a]bczdefzghiz"))
- (ert-info ("Substitute n flag does not replace")
- (evil-test-buffer
- "[a]bc\naef\nahi\n"
- (":%s/a//n" [return])
- "[a]bc\naef\nahi\n"))
- (ert-info ("Substitute n flag does not replace with g flag")
- (evil-test-buffer
- "[a]bc\naef\nahi\n"
- (":%s/a//gn" [return])
- "[a]bc\naef\nahi\n"))
- (ert-info ("Substitute $ does not loop infinitely")
- (evil-test-buffer
- "[a]bc\ndef\nghi"
- (":%s/$/ END/g" [return])
- "abc END\ndef END\n[g]hi END"))
- (ert-info ("Substitute the zero-length beginning of line character")
- (evil-test-buffer
- "[a]bc\ndef\nghi"
- (":s/^/ #/" [return])
- " [#]abc\ndef\nghi"))
- (ert-info ("Substitute the zero-length beginning of line character with g
flag")
- (evil-test-buffer
- "[a]bc\ndef\nghi"
- (":s/^/ #/g" [return])
- " [#]abc\ndef\nghi"))
- (ert-info ("Use Substitute to delete individual characters")
- (evil-test-buffer
- "[x]xyxxz"
- (":%s/x//g" [return])
- "[y]z")))
-
-(ert-deftest evil-test-ex-repeat-substitute-replacement ()
- "Test `evil-ex-substitute' with repeating of previous substitutions."
- :tags '(evil ex search)
- (ert-info ("Repeat previous pattern")
- (evil-select-search-module 'evil-search-module 'evil-search)
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar"
- (":s//BBB" [return])
- "[x]xx AAA bar BBB bar foo bar"
- ("/bar" [return] ":s//CCC" [return])
- "[x]xx AAA CCC BBB bar foo bar"
- (":s/ar/XX" [return])
- "[x]xx AAA CCC BBB bXX foo bar"
- (":s//YY" [return])
- "[x]xx AAA CCC BBB bXX foo bYY"))
- (ert-info ("Repeat previous replacement")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar"
- (":s/bar/~" [return])
- "[x]xx AAA AAA foo bar foo bar"))
- (ert-info ("Repeat with previous flags")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar"
- (":s/bar/BBB/&" [return])
- "[x]xx AAA BBB AAA BBB AAA BBB"))
- (ert-info ("Repeat previous substitute without flags")
- (evil-select-search-module 'evil-search-module 'evil-search)
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("j:s" [return])
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar foo bar foo bar"
- ("/bar" [return] ":s" [return])
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar AAA bar foo bar")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("j&")
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar foo bar foo bar")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("j:&" [return])
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar foo bar foo bar"))
- (ert-info ("Repeat previous substitute with the same flags")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("j:s//~/&" [return])
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar AAA bar AAA bar")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("j:&&" [return])
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar AAA bar AAA bar"))
- (ert-info ("Repeat previous substitute with new flags")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- ("j:s g" [return])
- "xxx AAA bar foo bar foo bar\n[x]xx AAA bar AAA bar AAA bar")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- ("j:& g" [return])
- "xxx AAA bar foo bar foo bar\n[x]xx AAA bar AAA bar AAA bar"))
- (ert-info ("Repeat with previous search pattern")
- (evil-select-search-module 'evil-search-module 'evil-search)
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- ("/bar" [return])
- "xxx AAA [b]ar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":2s rg" [return])
- "xxx AAA bar foo bar foo bar\n[x]xx foo AAA foo AAA foo AAA")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA" [return])
- "[x]xx AAA bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- ("/bar" [return])
- "xxx AAA [b]ar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":2~ g" [return])
- "xxx AAA bar foo bar foo bar\n[x]xx foo AAA foo AAA foo AAA"))
- (ert-info ("Repeat previous substitute globally")
- (evil-test-buffer
- "[x]xx foo bar foo bar foo bar\nxxx foo bar foo bar foo bar"
- (":s/foo/AAA/g" [return])
- "[x]xx AAA bar AAA bar AAA bar\nxxx foo bar foo bar foo bar"
- ("g&")
- "xxx AAA bar AAA bar AAA bar\n[x]xx AAA bar AAA bar AAA bar")))
-
-(ert-deftest evil-test-ex-regex-without-case ()
- "Test `evil-ex-regex-without-case'"
- :tags '(evil ex search)
- (should (equal (evil-ex-regex-without-case "cdeCDE")
- "cdeCDE"))
- (should (equal (evil-ex-regex-without-case "\\ccde\\CCDE")
- "cdeCDE"))
- (should (equal (evil-ex-regex-without-case "\\\\ccde\\\\CCDE")
- "\\\\ccde\\\\CCDE"))
- (should (equal (evil-ex-regex-without-case "\\\\\\ccde\\\\\\CCDE")
- "\\\\cde\\\\CDE")))
-
-(ert-deftest evil-test-ex-regex-case ()
- "Test `evil-ex-regex-case'"
- :tags '(evil ex search)
- (should (equal (evil-ex-regex-case "cde" 'smart) 'insensitive))
- (should (equal (evil-ex-regex-case "cDe" 'smart) 'sensitive))
- (should (equal (evil-ex-regex-case "cde" 'sensitive) 'sensitive))
- (should (equal (evil-ex-regex-case "cde" 'insensitive) 'insensitive))
- (should (equal (evil-ex-regex-case "\\ccde" 'smart) 'insensitive))
- (should (equal (evil-ex-regex-case "\\cCde" 'smart) 'insensitive))
- (should (equal (evil-ex-regex-case "\\Ccde" 'smart) 'sensitive))
- (should (equal (evil-ex-regex-case "\\CCde" 'smart) 'sensitive))
- (should (equal (evil-ex-regex-case "\\ccd\\Ce" 'smart) 'insensitive))
- (should (equal (evil-ex-regex-case "\\cCd\\Ce" 'smart) 'insensitive))
- (should (equal (evil-ex-regex-case "\\Ccd\\ce" 'smart) 'sensitive))
- (should (equal (evil-ex-regex-case "\\CCd\\ce" 'smart) 'sensitive)))
-
-(ert-deftest evil-test-ex-search ()
- "Test evil internal search."
- :tags '(evil ex search)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'evil-search)
- (ert-info ("Test smart case insensitive")
- (evil-test-buffer
- "[s]tart you YOU You you YOU You"
- ("/you" [return])
- "start [y]ou YOU You you YOU You"
- ("n")
- "start you [Y]OU You you YOU You"
- ("n")
- "start you YOU [Y]ou you YOU You"
- ("n")
- "start you YOU You [y]ou YOU You"))
- (ert-info ("Test smart case sensitive")
- (evil-test-buffer
- "[s]tart you YOU You you YOU You"
- ("/You" [return])
- "start you YOU [Y]ou you YOU You"
- ("n")
- "start you YOU You you YOU [Y]ou"))
- (ert-info ("Test insensitive")
- (evil-test-buffer
- "[s]tart you YOU You you YOU You"
- ("/\\cyou" [return])
- "start [y]ou YOU You you YOU You"
- ("n")
- "start you [Y]OU You you YOU You"
- ("n")
- "start you YOU [Y]ou you YOU You"
- ("n")
- "start you YOU You [y]ou YOU You"))
- (ert-info ("Test sensitive")
- (evil-test-buffer
- "[s]tart you YOU You you YOU You"
- ("/\\Cyou" [return])
- "start [y]ou YOU You you YOU You"
- ("n")
- "start you YOU You [y]ou YOU You"))
- (ert-info ("Test failing search does not move point")
- (evil-test-buffer
- "foo [f]oo foo\nbar bar2 bar\nbaz baz baz\n"
- (error search-failed "/foofoo" [return])
- "foo [f]oo foo\nbar bar2 bar\nbaz baz baz\n"
- ("/bar2" [return])
- "foo foo foo\nbar [b]ar2 bar\nbaz baz baz\n"
- ("dw")
- "foo foo foo\nbar [b]ar\nbaz baz baz\n"
- (error search-failed "n")
- "foo foo foo\nbar [b]ar\nbaz baz baz\n"
- (error search-failed "N")
- "foo foo foo\nbar [b]ar\nbaz baz baz\n"))
- (ert-info ("Test search for newline")
- (evil-test-buffer
- "[s]tart\nline 2\nline 3\n\n"
- ("/\\n" [return])
- "star[t]\nline 2\nline 3\n\n"
- ("n")
- "start\nline [2]\nline 3\n\n"
- ("n")
- "start\nline 2\nline [3]\n\n"
- ("n")
- "start\nline 2\nline 3\n[]\n"))))
-
-(ert-deftest evil-test-ex-search-offset ()
- "Test search offsets."
- :tags '(evil ex search)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'evil-search)
- (ert-info ("Test line offsets")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/2")
- "foo foo\nbar bar\nbaz baz\n[A]nother line\nAnd yet another line"
- ("?bar?-")
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/r bar/")
- "foo foo\nba[r] bar\nbaz baz\nAnother line\nAnd yet another line"))
- (ert-info ("Test end offsets")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/e")
- "foo foo\nba[r] bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/baz/e+2")
- "foo foo\nbar bar\nbaz [b]az\nAnother line\nAnd yet another line"
- ("/line/e-1")
- "foo foo\nbar bar\nbaz baz\nAnother li[n]e\nAnd yet another line"))
- (ert-info ("Test begin offsets")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/b")
- "foo foo\n[b]ar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/baz/b+2")
- "foo foo\nbar bar\nba[z] baz\nAnother line\nAnd yet another line"
- ("/line/b-")
- "foo foo\nbar bar\nbaz baz\nAnother[ ]line\nAnd yet another line"))
- (ert-info ("Test search-next with offset")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/ ba/+1" [return])
- "foo foo\nbar bar\n[b]az baz\nAnother line\nAnd yet another line"
- ("n")
- "foo foo\nbar bar\nbaz baz\n[A]nother line\nAnd yet another line"))
- (ert-info ("Test search next after /$")
- (evil-test-buffer
- "[l]ine 1\nline 2\n\n\line 4\n"
- ("/$" [return])
- "line [1]\nline 2\n\n\line 4\n"
- ("n")
- "line 1\nline [2]\n\n\line 4\n"
- ("n")
- "line 1\nline 2\n[\n]\line 4\n"
- ("n")
- "line 1\nline 2\n\n\line [4]\n"))))
-
-(ert-deftest evil-test-ex-search-pattern-offset ()
- "Test pattern offsets."
- :tags '(evil ex search)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'evil-search)
- (ert-info ("Test simple pattern offsets")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nfoo foo\nbaz baz\nAnother line\nAnd yet another
line"
- ("/bar/;/foo" [return])
- "foo foo\nbar bar\n[f]oo foo\nbaz baz\nAnother line\nAnd yet another
line"))
- (ert-info ("Test simple pattern offsets in backward direction")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nfoo foo\nbaz baz\nAnother line\nAnd yet another
line"
- ("/bar/;?foo" [return])
- "foo [f]oo\nbar bar\nfoo foo\nbaz baz\nAnother line\nAnd yet another
line"))
- (ert-info ("Ensure second pattern is used for search repeat")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nfoo foo\nbaz baz\nAnother line\nAnd yet another
line"
- ("/bar/;?foo" [return] "n")
- "foo foo\nbar bar\n[f]oo foo\nbaz baz\nAnother line\nAnd yet another
line"))))
-
-(ert-deftest evil-test-ex-search-repeat ()
- "Test repeat of search."
- :tags '(evil ex search)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'evil-search)
- (ert-info ("Test repeat of simple pattern")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar" [return] "/" [return])
- "foo foo\nbar [b]ar\nbaz baz\nAnother line\nAnd yet another line"))
- (ert-info ("Test repeat of simple pattern with new offset")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar" [return] "//e" [return])
- "foo foo\nbar ba[r]\nbaz baz\nAnother line\nAnd yet another line"))
- (ert-info ("Test repeat of pattern with offset")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/e" [return] "/" [return])
- "foo foo\nbar ba[r]\nbaz baz\nAnother line\nAnd yet another line"))
- (ert-info ("Test repeat of pattern with offset without offset")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/e" [return] "//" [return])
- "foo foo\nbar [b]ar\nbaz baz\nAnother line\nAnd yet another line"))
- (ert-info ("Test repeat of pattern with offset with new offset")
- (evil-test-buffer
- "[f]oo foo\nbar bar\nbaz baz\nAnother line\nAnd yet another line"
- ("/bar/e" [return] "//b+1" [return])
- "foo foo\nbar b[a]r\nbaz baz\nAnother line\nAnd yet another line"))))
-
-(ert-deftest evil-test-ex-search-word ()
- "Test search for word under point."
- :tags '(evil ex search)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'evil-search)
- (setq evil-ex-search-history nil)
- (evil-test-buffer
- "so[m]e text with a strange word
-and here some other stuff
-maybe we need one line more with some text\n"
- (setq evil-symbol-word-search nil)
- ("*")
- "some text with a strange word
-and here [s]ome other stuff
-maybe we need one line more with some text\n"
- ("n")
- "some text with a strange word
-and here some other stuff
-maybe we need one line more with [s]ome text\n"
- (ert-info ("Search history")
- (should (equal evil-ex-search-history '("\\<some\\>"))))
- ("*")
- "[s]ome text with a strange word
-and here some other stuff
-maybe we need one line more with some text\n"
- (ert-info ("Search history with double pattern")
- (should (equal evil-ex-search-history '("\\<some\\>")))))
- (ert-info ("Test unbounded search")
- (evil-select-search-module 'evil-search-module 'evil-search)
- (setq evil-ex-search-history nil)
- (evil-test-buffer
- "[s]ymbol\n(defun my-symbolfunc ())\n(defvar my-symbolvar)\nanother
symbol\n"
- ("*")
- (setq evil-symbol-word-search nil)
- "symbol\n(defun my-symbolfunc ())\n(defvar my-symbolvar)\nanother
[s]ymbol\n"
- ("ggg*")
- "symbol\n(defun my-[s]ymbolfunc ())\n(defvar my-symbolvar)\nanother
symbol\n"
- (should (equal evil-ex-search-history '("symbol" "\\<symbol\\>")))
- ("n")
- "symbol\n(defun my-symbolfunc ())\n(defvar my-[s]ymbolvar)\nanother
symbol\n"))
- (ert-info ("Test symbol search")
- (evil-select-search-module 'evil-search-module 'evil-search)
- (evil-test-buffer
- "(defun my-s[y]mbol-func ())\n(defvar
my-symbol-var)\n(my-symbol-func)\n(setq my-symbol-func2 (my-symbol-func))\n"
- (setq evil-symbol-word-search t)
- ("*")
- "(defun my-symbol-func ())\n(defvar
my-symbol-var)\n([m]y-symbol-func)\n(setq my-symbol-func2 (my-symbol-func))\n"
- ("n")
- "(defun my-symbol-func ())\n(defvar
my-symbol-var)\n(my-symbol-func)\n(setq my-symbol-func2
([m]y-symbol-func))\n"))))
-
-(ert-deftest evil-test-isearch-word ()
- "Test isearch for word under point."
- :tags '(evil isearch)
- (evil-without-display
- (evil-select-search-module 'evil-search-module 'isearch)
- (evil-test-buffer
- "so[m]e text with a strange word
-and here some other stuff
-maybe we need one line more with some text\n"
- (setq evil-symbol-word-search nil)
- ("*")
- "some text with a strange word
-and here [s]ome other stuff
-maybe we need one line more with some text\n"
- ("n")
- "some text with a strange word
-and here some other stuff
-maybe we need one line more with [s]ome text\n"
- ("*")
- "[s]ome text with a strange word
-and here some other stuff
-maybe we need one line more with some text\n")
- (ert-info ("Test unbounded search")
- (evil-select-search-module 'evil-search-module 'isearch)
- (evil-test-buffer
- "[s]ymbol\n(defun my-symbolfunc ())\n(defvar my-symbolvar)\nanother
symbol\n"
- (setq evil-symbol-word-search nil)
- ("*")
- "symbol\n(defun my-symbolfunc ())\n(defvar my-symbolvar)\nanother
[s]ymbol\n"
- ("ggg*")
- "symbol\n(defun my-[s]ymbolfunc ())\n(defvar my-symbolvar)\nanother
symbol\n"
- ("n")
- "symbol\n(defun my-symbolfunc ())\n(defvar my-[s]ymbolvar)\nanother
symbol\n"))
- (ert-info ("Test symbol search")
- (evil-select-search-module 'evil-search-module 'isearch)
- (evil-test-buffer
- "(defun my-s[y]mbol-func ())\n(defvar
my-symbol-var)\n(my-symbol-func)\n(setq my-symbol-func2 (my-symbol-func))\n"
- (setq evil-symbol-word-search t)
- ("*")
- "(defun my-symbol-func ())\n(defvar
my-symbol-var)\n([m]y-symbol-func)\n(setq my-symbol-func2 (my-symbol-func))\n"
- ("n")
- "(defun my-symbol-func ())\n(defvar
my-symbol-var)\n(my-symbol-func)\n(setq my-symbol-func2
([m]y-symbol-func))\n"))))
-
-(ert-deftest evil-test-read ()
- "Test of `evil-read'"
- :tags '(evil ex)
- (evil-without-display
- (ert-info ("Test insertion of file with trailing newline")
- (evil-with-temp-file name
- "temp file 1\ntemp file 2\n"
- (ert-info ("At first line")
- (evil-test-buffer
- "[l]ine 1\nline 2"
- ((vconcat ":read " name [return]))
- "line 1\n[t]emp file 1\ntemp file 2\nline 2"))
- (ert-info ("At last line")
- (evil-test-buffer
- "line 1\n[l]ine 2"
- ((vconcat ":read " name [return]))
- "line 1\nline 2\n[t]emp file 1\ntemp file 2\n"))
- (ert-info ("After specified line number")
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4\line 5"
- ((vconcat ":3read " name [return]))
- "line 1\nline 2\nline 3\n[t]emp file 1\ntemp file 2\nline 4\line
5"))
- (ert-info ("After specified line 0")
- (evil-test-buffer
- "line 1\nline [2]\nline 3\nline 4\line 5"
- ((vconcat ":0read " name [return]))
- "[t]emp file 1\ntemp file 2\nline 1\nline 2\nline 3\nline 4\line
5"))))
- (ert-info ("Test insertion of file without trailing newline")
- (evil-with-temp-file name
- "temp file 1\ntemp file 2"
- (evil-test-buffer
- "[l]ine 1\nline 2"
- ((vconcat ":read " name [return]))
- "line 1\n[t]emp file 1\ntemp file 2\nline 2")))
- (ert-info ("Test insertion of shell command")
- (ert-info ("with space")
- (evil-test-buffer
- "[l]line 1\nline 2"
- (":read !echo cmd line 1" [return])
- "line 1\n[c]md line 1\nline 2"))
- (ert-info ("without space")
- (evil-test-buffer
- "[l]line 1\nline 2"
- (":read!echo cmd line 1" [return])
- "line 1\n[c]md line 1\nline 2")))
- (ert-info ("Test insertion of shell command without trailing newline")
- (ert-info ("with space")
- (evil-test-buffer
- "[l]line 1\nline 2"
- (":read !echo -n cmd line 1" [return])
- "line 1\n[c]md line 1\nline 2"))
- (ert-info ("without space")
- (evil-test-buffer
- "[l]line 1\nline 2"
- (":read!echo -n cmd line 1" [return])
- "line 1\n[c]md line 1\nline 2")))))
-
-(ert-deftest evil-test-shell-command ()
- "Test `evil-shell-command'."
- (ert-info ("ex shell command")
- (evil-test-buffer
- "[l]ine 5\nline 4\nline 3\nline 2\nline 1\n"
- (":2,3!sort" [return])
- "line 5\n[l]ine 3\nline 4\nline 2\nline 1\n"))
- (ert-info ("shell command operator with count")
- (evil-test-buffer
- "line 5\n[l]ine 4\nline 3\nline 2\nline 1\n"
- ("2!!sort" [return])
- "line 5\n[l]ine 3\nline 4\nline 2\nline 1\n"))
- (ert-info ("shell command operator with motion")
- (evil-test-buffer
- "line 5\n[l]ine 4\nline 3\nline 2\nline 1\n"
- ("!jsort" [return])
- "line 5\n[l]ine 3\nline 4\nline 2\nline 1\n"))
- (ert-info ("shell command operator with backward motion")
- (evil-test-buffer
- "line 5\nline 4\n[l]ine 3\nline 2\nline 1\n"
- ("!ksort" [return])
- "line 5\n[l]ine 3\nline 4\nline 2\nline 1\n"))
- (ert-info ("shell command operator with visual selection")
- (evil-test-buffer
- "line 5\n[l]ine 4\nline 3\nline 2\nline 1\n"
- ("vj!sort" [return])
- "line 5\n[l]ine 3\nline 4\nline 2\nline 1\n")))
-
-(ert-deftest evil-test-global ()
- "Test `evil-ex-global'."
- :tags '(evil ex global)
- (ert-info ("global delete")
- (evil-test-buffer
- "[n]o 1\nno 2\nno 3\nyes 4\nno 5\nno 6\nno 7\n"
- (":g/yes/d" [return])
- "no 1\nno 2\nno 3\n[n]o 5\nno 6\nno 7\n"))
- (ert-info ("global substitute")
- (evil-test-buffer
- "[n]o 1\nno 2\nno 3\nyes 4\nno 5\nno 6\nno 7\n"
- (":g/no/s/[3-6]/x" [return])
- "no 1\nno 2\nno x\nyes 4\nno x\nno x\n[n]o 7\n"
- ("u")
- "no 1\nno 2\nno [3]\nyes 4\nno 5\nno 6\nno 7\n"))
- (evil-select-search-module 'evil-search-module 'evil-search)
- (ert-info ("global use last match if none given, with evil-search")
- (evil-test-buffer
- "[n]o 1\nno 2\nno 3\nyes 4\nno 5\nno 6\nno 7\n"
- ("/yes" [return])
- "no 1\nno 2\nno 3\nyes 4\nno 5\nno 6\nno 7\n"
- (":g//d" [return])
- "no 1\nno 2\nno 3\n[n]o 5\nno 6\nno 7\n"
- (":v//d" [return])
- ""))
- (evil-select-search-module 'evil-search-module 'isearch)
- (ert-info ("global use last match if none given, with isearch")
- (evil-test-buffer
- "[n]o 1\nno 2\nno 3\nisearch 4\nno 5\nno 6\nno 7\n"
- ("/isearch" [return])
- "no 1\nno 2\nno 3\nisearch 4\nno 5\nno 6\nno 7\n"
- (":g//d" [return])
- "no 1\nno 2\nno 3\n[n]o 5\nno 6\nno 7\n"
- (":v//d" [return])
- "")))
-
-(ert-deftest evil-test-normal ()
- "Test `evil-ex-normal'."
- :tags '(evil ex)
- (let (evil-want-fine-undo)
- (evil-test-buffer
- "[l]ine 1\nline 2\nline 3\nline 4\nline 5\n"
- (":normal lxIABC" [escape] "AXYZ" [return])
- "ABClne 1XY[Z]\nline 2\nline 3\nline 4\nline 5\n"
- (":3,4normal lxIABC" [escape] "AXYZ" [return])
- "ABClne 1XYZ\nline 2\nABClne 3XYZ\nABClne 4XY[Z]\nline 5\n"
- ("u")
- "ABClne 1XYZ\nline 2\nl[i]ne 3\nline 4\nline 5\n")))
-
-(ert-deftest evil-test-copy ()
- :tags '(evil ex)
- "Test `evil-copy'."
- (ert-info ("Copy to last line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,3copy$")
- "line1\nline2\nline3\nline4\nline5\nline2\n[l]ine3\n"))
- (ert-info ("Copy to last incomplete line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5"
- (":2,3copy$")
- "line1\nline2\nline3\nline4\nline5\nline2\n[l]ine3\n"))
- (ert-info ("Copy incomplete line to last incomplete line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5"
- (":4,5copy$")
- "line1\nline2\nline3\nline4\nline5\nline4\n[l]ine5\n"))
- (ert-info ("Copy to first line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,3copy0")
- "line2\n[l]ine3\nline1\nline2\nline3\nline4\nline5\n"))
- (ert-info ("Copy to intermediate line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,4copy2")
- "line1\nline2\nline2\nline3\n[l]ine4\nline3\nline4\nline5\n"))
- (ert-info ("Copy to current line")
- (evil-test-buffer
- "line1\nline2\nline3\nli[n]e4\nline5\n"
- (":2,4copy.")
- "line1\nline2\nline3\nline4\nline2\nline3\n[l]ine4\nline5\n")))
-
-(ert-deftest evil-test-move ()
- :tags '(evil ex)
- "Test `evil-move'."
- (ert-info ("Move to last line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,3move$")
- "line1\nline4\nline5\nline2\n[l]ine3\n"))
- (ert-info ("Move to last incomplete line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5"
- (":2,3move$")
- "line1\nline4\nline5\nline2\n[l]ine3\n"))
- (ert-info ("Move incomplete line to last incomplete line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5"
- (":4,5move$")
- "line1\nline2\nline3\nline4\n[l]ine5\n"))
- (ert-info ("Move to first line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,3move0")
- "line2\n[l]ine3\nline1\nline4\nline5\n"))
- (ert-info ("Move to intermediate line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,4move2")
- "line1\nline2\nline3\n[l]ine4\nline5\n"))
- (ert-info ("Move to other line")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- (":2,3move4")
- "line1\nline4\nline2\n[l]ine3\nline5\n"))
- (ert-info ("Move to current line")
- (evil-test-buffer
- "line1\nline2\nline3\nli[n]e4\nline5\n"
- (":2,4move.")
- "line1\nline2\nline3\n[l]ine4\nline5\n")))
-
-(ert-deftest evil-test-write ()
- :tags '(evil ex)
- "Test `evil-write'."
- (ert-info ("Write open file")
- (evil-with-temp-file filename "line1\nline2\nline3\n"
- (evil-test-buffer
- ((vconcat ":e " filename [return]))
- "[l]ine1\nline2\nline3\n"
- ("Galine4\nline5\n" [escape])
- "line1\nline2\nline3\nline4\nline5\n"
- (":w")
- (file filename "line1\nline2\nline3\nline4\nline5\n"))))
- (let ((filename (evil-temp-filename)))
- (ert-info ("Write current buffer to new file")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- ((vconcat ":w " filename [return]))
- (file filename "line1\nline2\nline3\nline4\nline5\n")
- (delete-file filename)))
- (ert-info ("Write part of a buffer")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- ((vconcat ":2,3w " filename [return]))
- (file filename "line2\nline3\n")
- (delete-file filename)))
- (ert-info ("Appending a file")
- (evil-test-buffer
- "[l]ine1\nline2\nline3\nline4\nline5\n"
- ((vconcat ":4w " filename [return]))
- (file filename "line4\n")
- ((vconcat ":1,2w >>" filename [return]))
- (file filename "line4\nline1\nline2\n")
- ((vconcat ":w >> " filename [return]))
- (file filename
- "line4\nline1\nline2\nline1\nline2\nline3\nline4\nline5\n")
- (delete-file filename)))))
-
-(ert-deftest evil-test-ex-sort ()
- :tags '(evil ex)
- "Text ex command :sort `evil-ex-sort`."
- (ert-info ("Plain sort")
- (evil-test-buffer
- "[z]zyy\ntest\ntEst\ntesT\nTEST\ntest\n"
- (":sort")
- "[T]EST\ntEst\ntesT\ntest\ntest\nzzyy\n"))
- (ert-info ("Reverse sort")
- (evil-test-buffer
- "[z]zyy\ntest\ntEst\ntesT\nTEST\ntest\n"
- (":sort!")
- "[z]zyy\ntest\ntest\ntesT\ntEst\nTEST\n"))
- (ert-info ("case insensitive")
- (evil-test-buffer
- "[z]zyy\ntest\ntEst\ntesT\nTEST\ntest\n"
- (":sort i")
- "[t]est\ntEst\ntesT\nTEST\ntest\nzzyy\n"))
- (ert-info ("unique")
- (evil-test-buffer
- "[z]zyy\ntest\ntEst\ntesT\nTEST\ntest\n"
- (":sort u")
- "[T]EST\ntEst\ntesT\ntest\nzzyy\n"))
- (ert-info ("case insensitive and unique")
- (evil-test-buffer
- "[z]zyy\ntest\ntEst\ntesT\nTEST\ntest\n"
- (":sort iu")
- "[t]est\nzzyy\n")))
-
-;;; Command line window
-
-;; (ert-deftest evil-test-command-window-ex ()
-;; "Test command line window for ex commands"
-;; (let (evil-ex-history)
-;; (evil-test-buffer
-;; "[f]oo foo foo"
-;; (":s/foo/bar" [return])
-;; "[b]ar foo foo"
-;; (":s/foo/baz" [return])
-;; "[b]ar baz foo"
-;; ("q:")
-;; "s/foo/bar\ns/foo/baz\n[]\n"
-;; ("kk:s/bar/quz" [return])
-;; "[s]/foo/quz\ns/foo/baz\n"
-;; ("fzrx")
-;; "s/foo/qu[x]\ns/foo/baz\n"
-;; ([return])
-;; "[b]ar baz qux"
-;; (should (equal (car evil-ex-history)
-;; "s/foo/qux")))))
-
-;; (ert-deftest evil-test-command-window-recursive ()
-;; "Test that recursive command windows shouldn't be allowed"
-;; (let ((evil-command-window-height 0))
-;; (evil-test-buffer
-;; "[f]oo foo foo"
-;; (":s/foo/bar" [return])
-;; ("q:")
-;; (should-error (execute-kbd-macro "q:")))))
-
-;; (ert-deftest evil-test-command-window-noop ()
-;; "Test that executing a blank command does nothing"
-;; (evil-test-buffer
-;; "[f]oo foo foo"
-;; ("q:")
-;; "[]\n"
-;; ([return])
-;; "[f]oo foo foo"))
-
-;; (ert-deftest evil-test-command-window-multiple ()
-;; "Test that multiple command line windows can't be visible at the same
time"
-;; (let ((evil-command-window-height 0))
-;; (evil-test-buffer
-;; "[f]oo foo foo"
-;; ("q:")
-;; (let ((num-windows (length (window-list))))
-;; (select-window (previous-window))
-;; (execute-kbd-macro "q:")
-;; (should (= (length (window-list)) num-windows))))))
-
-(defmacro evil-with-both-search-modules (&rest body)
- `(mapc (lambda (search-module)
- (setq evil-search-forward-history nil
- evil-search-backward-history nil
- evil-ex-search-history nil)
- (evil-select-search-module 'evil-search-module search-module)
- ,@body)
- '(isearch evil-search)))
-
-;; (ert-deftest evil-test-command-window-search-history ()
-;; "Test command window with forward and backward search history"
-;; (let ((evil-search-module 'isearch))
-;; (evil-test-buffer
-;; "[f]oo bar baz qux one two three four"
-;; ("/qux" [return])
-;; "foo bar baz [q]ux one two three four"
-;; ("/three" [return])
-;; "foo bar baz qux one two [t]hree four"
-;; ("?bar" [return])
-;; "foo [b]ar baz qux one two three four"
-;; ("/four" [return])
-;; "foo bar baz qux one two three [f]our"
-;; ("?baz" [return])
-;; "foo bar [b]az qux one two three four"
-;; ("q/")
-;; "qux\nthree\nfour\n[]\n"
-;; ("k" [return])
-;; "foo bar baz qux one two three [f]our"
-;; ("0N")
-;; "foo bar baz qux one two three [f]our"
-;; ("q?")
-;; "bar\nbaz\n[]\n"
-;; ("k$rr" [return])
-;; "foo [b]ar baz qux one two three four"
-;; (should-error
-;; (progn (execute-kbd-macro "q/iNOT THERE")
-;; (execute-kbd-macro [return])))
-;; "foo [b]ar baz qux one two three four")))
-
-;; (ert-deftest evil-test-command-window-search-word ()
-;; "Test command window history when searching for word under cursor"
-;; (let ((evil-search-module 'isearch))
-;; (evil-test-buffer
-;; "[f]oo bar foo bar foo"
-;; ("**")
-;; "foo bar foo bar [f]oo"
-;; ("B#")
-;; "foo [b]ar foo bar foo"
-;; ("q/k" [return])
-;; "foo bar [f]oo bar foo"
-;; ("q?k" [return])
-;; "foo [b]ar foo bar foo")))
-
-;;; Utilities
-
-(ert-deftest evil-test-parser ()
- "Test `evil-parser'"
- (let ((grammar '((number "[0-9]+" #'string-to-number)
- (plus "\\+" #'intern)
- (minus "-" #'intern)
- (operator
- plus
- minus)
- (sign
- ((\? operator) #'$1))
- (signed-number
- (sign number))
- (inc
- (number #'(lambda (n) (1+ n))))
- (expr
- (number operator number)
- ("2" #'"1+1"))
- (epsilon nil))))
- (ert-info ("Nothing")
- (should (equal (evil-parser "1+2" nil grammar t)
- nil))
- (should (equal (evil-parser "1+2" nil grammar)
- '(nil . "1+2")))
- (should (equal (evil-parser "1+2" 'epsilon grammar t)
- nil))
- (should (equal (evil-parser "1+2" 'epsilon grammar)
- '(nil . "1+2"))))
- (ert-info ("Strings")
- (should (equal (evil-parser "1" 'number grammar t)
- '((string-to-number "1"))))
- (should (equal (evil-parser "11" 'number grammar)
- '((string-to-number "11") . ""))))
- (ert-info ("Sequences")
- (should (equal (evil-parser "1" '(number) grammar t)
- '((list (string-to-number "1")))))
- (should (equal (evil-parser "1+2" '(number operator number) grammar t)
- '((list
- (string-to-number "1")
- (intern "+")
- (string-to-number "2"))))))
- (ert-info ("Symbols")
- (should (equal (evil-parser "+" 'plus grammar t)
- '((intern "+"))))
- (should (equal (evil-parser "+" 'operator grammar t)
- '((intern "+"))))
- (should (equal (evil-parser "1" 'number grammar t)
- '((string-to-number "1")))))
- (ert-info ("Whitespace")
- (should (equal (evil-parser " 1" 'number grammar t)
- '((string-to-number "1")))))
- (ert-info ("One or more")
- (should (equal (evil-parser "1 2 3" '(+ number) grammar t)
- '((list
- (string-to-number "1")
- (string-to-number "2")
- (string-to-number "3")))))
- (should (equal (evil-parser "1 2 3" '(* number) grammar t)
- '((list
- (string-to-number "1")
- (string-to-number "2")
- (string-to-number "3")))))
- (should (equal (evil-parser "1 2 3" '(\? number) grammar)
- '((string-to-number "1") . " 2 3")))
- (should (equal (evil-parser "1 2 3" '(\? number number) grammar)
- '((list
- (string-to-number "1")
- (string-to-number "2"))
- . " 3")))
- (should (equal (evil-parser "1 2 3" '(number (\? number)) grammar)
- '((list
- (string-to-number "1")
- (string-to-number "2"))
- . " 3")))
- (should (equal (evil-parser "1 2 3" '(number (\? number number)) grammar)
- '((list
- (string-to-number "1")
- (list
- (string-to-number "2")
- (string-to-number "3")))
- . "")))
- (should (equal (evil-parser "1 a 3" '(number (\? number)) grammar)
- '((list
- (string-to-number "1")
- nil)
- . " a 3")))
- (should (equal (evil-parser "1" 'signed-number grammar t t)
- '((signed-number (sign "") (number "1")) . ""))))
- (ert-info ("Lookahead")
- (should (equal (evil-parser "foobar" '("foo" (& "bar")) grammar)
- '((list "foo") . "bar")))
- (should (equal (evil-parser "foobar" '("foo" (! "bar")) grammar)
- nil))
- (should (equal (evil-parser "foobar" '("foo" (& "baz")) grammar)
- nil))
- (should (equal (evil-parser "foobar" '("foo" (! "baz")) grammar)
- '((list "foo") . "bar"))))
- (ert-info ("Semantic actions")
- (should (equal (evil-parser "1" 'inc grammar t)
- '((funcall (lambda (n)
- (1+ n))
- (string-to-number "1")))))
- (should (equal (evil-parser "1+1" 'expr grammar t)
- '((list
- (string-to-number "1")
- (intern "+")
- (string-to-number "1")))))
- (should (equal (evil-parser "2" 'expr grammar t)
- '((list (string-to-number "1")
- (intern "+")
- (string-to-number "1"))))))))
-
-(ert-deftest evil-test-delimited-arguments ()
- "Test `evil-delimited-arguments'"
- :tags '(evil util)
- (ert-info ("Any number of arguments")
- (should (equal (evil-delimited-arguments "/a/b/c/")
- '("a" "b" "c")))
- (should (equal (evil-delimited-arguments "/a/b/c")
- '("a" "b" "c")))
- (should (equal (evil-delimited-arguments "/a/b//")
- '("a" "b" "")))
- (should (equal (evil-delimited-arguments "/a///")
- '("a" "" "")))
- (should (equal (evil-delimited-arguments "/a/ ")
- '("a" " ")))
- (should (equal (evil-delimited-arguments "/a/")
- '("a")))
- (should (equal (evil-delimited-arguments "//b//")
- '("" "b" "")))
- (should (equal (evil-delimited-arguments "/a//c")
- '("a" "" "c")))
- (should (equal (evil-delimited-arguments "////")
- '("" "" "")))
- (should (equal (evil-delimited-arguments "/")
- nil))
- (should (equal (evil-delimited-arguments " ")
- nil))
- (should (equal (evil-delimited-arguments "")
- nil)))
- (ert-info ("Two arguments")
- (should (equal (evil-delimited-arguments "/a/b/c" 2)
- '("a" "b/c")))
- (should (equal (evil-delimited-arguments "/a/b/" 2)
- '("a" "b")))
- (should (equal (evil-delimited-arguments "/a/b" 2)
- '("a" "b")))
- (should (equal (evil-delimited-arguments "/a//" 2)
- '("a" "")))
- (should (equal (evil-delimited-arguments "/a/ " 2)
- '("a" " ")))
- (should (equal (evil-delimited-arguments "/a/" 2)
- '("a" nil)))
- (should (equal (evil-delimited-arguments "/a" 2)
- '("a" nil)))
- (should (equal (evil-delimited-arguments " " 2)
- '(nil nil)))
- (should (equal (evil-delimited-arguments "" 2)
- '(nil nil))))
- (ert-info ("One argument")
- (should (equal (evil-delimited-arguments "/a/b/c" 1)
- '("a/b/c")))
- (should (equal (evil-delimited-arguments "/a/ " 1)
- '("a")))
- (should (equal (evil-delimited-arguments "/a/" 1)
- '("a")))
- (should (equal (evil-delimited-arguments "/a" 1)
- '("a")))
- (should (equal (evil-delimited-arguments "/" 1)
- '(nil)))
- (should (equal (evil-delimited-arguments " " 1)
- '(nil)))
- (should (equal (evil-delimited-arguments "" 1)
- '(nil))))
- (ert-info ("Zero arguments")
- (should (equal (evil-delimited-arguments "/a" 0)
- nil))
- (should (equal (evil-delimited-arguments "/" 0)
- nil))
- (should (equal (evil-delimited-arguments " " 0)
- nil))
- (should (equal (evil-delimited-arguments "" 0)
- nil))))
-
-(ert-deftest evil-test-concat-charsets ()
- "Test `evil-concat-charsets'"
- :tags '(evil util)
- (ert-info ("Bracket")
- (should (equal (evil-concat-charsets "abc" "]def")
- "]abcdef")))
- (ert-info ("Complement")
- (should (equal (evil-concat-charsets "^abc" "def")
- "^abcdef"))
- (should (equal (evil-concat-charsets "^abc" "^def")
- "^abcdef")))
- (ert-info ("Hyphen")
- (should (equal (evil-concat-charsets "abc" "-def")
- "-abcdef"))
- (should (equal (evil-concat-charsets "^abc" "-def")
- "^-abcdef")))
- (ert-info ("Newline")
- (should (equal (evil-concat-charsets "^ \t\r\n" "[:word:]_")
- "^ \t\r\n[:word:]_"))))
-
-(ert-deftest evil-test-properties ()
- "Test `evil-get-property' and `evil-put-property'"
- :tags '(evil util)
- (let (alist)
- (ert-info ("Set properties")
- (evil-put-property 'alist 'wibble :foo t)
- (should (equal alist '((wibble . (:foo t)))))
- (evil-put-property 'alist 'wibble :bar nil)
- (should (equal alist '((wibble . (:foo t :bar nil)))))
- (evil-put-property 'alist 'wobble :foo nil :bar nil :baz t)
- (should (equal alist '((wobble . (:foo nil :bar nil :baz t))
- (wibble . (:foo t :bar nil))))))
- (ert-info ("Get properties")
- (should (evil-get-property alist 'wibble :foo))
- (should-not (evil-get-property alist 'wibble :bar))
- (should-not (evil-get-property alist 'wobble :foo))
- (should-not (evil-get-property alist 'wibble :baz))
- (should (equal (evil-get-property alist t :foo)
- '((wibble . t) (wobble . nil))))
- (should (equal (evil-get-property alist t :bar)
- '((wibble . nil) (wobble . nil))))
- (should (equal (evil-get-property alist t :baz)
- '((wobble . t)))))))
-
-(ert-deftest evil-test-filter-list ()
- "Test `evil-filter-list'"
- :tags '(evil util)
- (ert-info ("Return filtered list")
- (should (equal (evil-filter-list #'null '(nil)) nil))
- (should (equal (evil-filter-list #'null '(nil 1)) '(1)))
- (should (equal (evil-filter-list #'null '(nil 1 2 nil)) '(1 2)))
- (should (equal (evil-filter-list #'null '(nil nil 1)) '(1)))
- (should (equal (evil-filter-list #'null '(nil 1 nil 2 nil 3))
- '(1 2 3))))
- (ert-info ("Remove matches by side-effect when possible")
- (let (list)
- (setq list '(1 nil))
- (evil-filter-list #'null list)
- (should (equal list '(1)))
-
- (setq list '(1 nil nil))
- (evil-filter-list #'null list)
- (should (equal list '(1)))
-
- (setq list '(1 nil nil 2))
- (evil-filter-list #'null list)
- (should (equal list '(1 2)))
-
- (setq list '(1 nil 2 nil 3))
- (evil-filter-list #'null list)
- (should (equal list '(1 2 3))))))
-
-(ert-deftest evil-test-concat-lists ()
- "Test `evil-concat-lists' and `evil-concat-alists'"
- :tags '(evil util)
- (ert-info ("Remove duplicates across lists")
- (should (equal (evil-concat-lists
- nil '(a b) '(b c))
- '(a b c))))
- (ert-info ("Remove duplicates inside lists")
- (should (equal (evil-concat-lists
- '(a a b) nil '(b c) nil)
- '(a b c))))
- (ert-info ("Remove duplicate associations")
- (should (equal (evil-concat-alists
- '((a . b)) '((a . c)))
- '((a . c))))
- (should-not (equal (evil-concat-lists
- '((a . b)) '((a . c)))
- '((a . b))))))
-
-(ert-deftest evil-test-sort ()
- "Test `evil-sort' and `evil-swap'"
- :tags '(evil util)
- (let (a b c d)
- (ert-info ("Two elements")
- (setq a 2 b 1)
- (evil-sort a b)
- (should (= a 1))
- (should (= b 2))
- (evil-swap a b)
- (should (= a 2))
- (should (= b 1)))
- (ert-info ("Three elements")
- (setq a 3 b 1 c 2)
- (evil-sort a b c)
- (should (= a 1))
- (should (= b 2))
- (should (= c 3)))
- (ert-info ("Four elements")
- (setq a 4 b 3 c 2 d 1)
- (evil-sort a b c d)
- (should (= a 1))
- (should (= b 2))
- (should (= c 3))
- (should (= d 4)))))
-
-(ert-deftest evil-test-read-key ()
- "Test `evil-read-key'"
- :tags '(evil util)
- (let ((unread-command-events '(?A)))
- (ert-info ("Prevent downcasing in `this-command-keys'")
- (should (eq (evil-read-key) ?A))
- (should (equal (this-command-keys) "A")))))
-
-(ert-deftest evil-test-extract-count ()
- "Test `evil-extract-count'"
- :tags '(evil util)
- (evil-test-buffer
- (ert-info ("Exact without count")
- (should (equal (evil-extract-count "x")
- (list nil 'evil-delete-char "x" nil)))
- (should (equal (evil-extract-count "g0")
- (list nil 'evil-beginning-of-visual-line "g0" nil))))
-
- (ert-info ("Exact with count")
- (should (equal (evil-extract-count "420x")
- (list 420 'evil-delete-char "x" nil)))
- (should (equal (evil-extract-count (vconcat "420" [M-right]))
- (list 420 (key-binding [M-right]) (vconcat [M-right])
nil)))
- (should (equal (evil-extract-count "2301g0")
- (list 2301 'evil-beginning-of-visual-line "g0" nil))))
-
- (ert-info ("Extra elements without count")
- (should (equal (evil-extract-count "xAB")
- (list nil 'evil-delete-char "x" "AB")))
- (should (equal (evil-extract-count "g0CD")
- (list nil 'evil-beginning-of-visual-line "g0" "CD"))))
-
- (ert-info ("Extra elements with count")
- (should (equal (evil-extract-count "420xAB")
- (list 420 'evil-delete-char "x" "AB")))
- (should (equal (evil-extract-count "2301g0CD")
- (list 2301 'evil-beginning-of-visual-line "g0" "CD"))))
-
- (ert-info ("Exact \"0\" count")
- (should (equal (evil-extract-count "0")
- (list nil 'evil-digit-argument-or-evil-beginning-of-line
- "0" nil))))
-
- (ert-info ("Extra elements and \"0\"")
- (should (equal (evil-extract-count "0XY")
- (list nil 'evil-digit-argument-or-evil-beginning-of-line
- "0" "XY"))))
-
- (ert-info ("Count only")
- (should-error (evil-extract-count "1230")))
-
- (ert-info ("Unknown command")
- (should-error (evil-extract-count "°"))
- (should-error (evil-extract-count "12°")))))
-
-(ert-deftest evil-transform-vim-style-regexp ()
- "Test `evil-transform-vim-style-regexp'"
- (dolist (repl '((?s . "[[:space:]]")
- (?S . "[^[:space:]]")
- (?d . "[[:digit:]]")
- (?D . "[^[:digit:]]")
- (?x . "[[:xdigit:]]")
- (?X . "[^[:xdigit:]]")
- (?o . "[0-7]")
- (?O . "[^0-7]")
- (?a . "[[:alpha:]]")
- (?A . "[^[:alpha:]]")
- (?l . "[a-z]")
- (?L . "[^a-z]")
- (?u . "[A-Z]")
- (?U . "[^A-Z]")
- (?y . "\\s")
- (?Y . "\\S")
- (?w . "\\w")
- (?W . "\\W")))
- (ert-info ((format "Test transform from '\\%c' to '%s'"
- (car repl) (cdr repl)))
- (should (equal (evil-transform-vim-style-regexp
- (concat "xxx\\"
- (char-to-string (car repl))
- "\\"
- (char-to-string (car repl))
- "\\\\"
- (char-to-string (car repl))
- "\\\\\\"
- (char-to-string (car repl))
- "yyy"))
- (concat "xxx"
- (cdr repl)
- (cdr repl)
- "\\\\"
- (char-to-string (car repl))
- "\\\\"
- (cdr repl)
- "yyy"))))))
-
-;;; Advice
-
-(ert-deftest evil-test-eval-last-sexp ()
- "Test advised `evil-last-sexp'"
- :tags '(evil advice)
- (ert-info ("Normal state")
- (evil-test-buffer
- "(+ 1 (+ 2 3[)])"
- ("1" (kbd "C-x C-e"))
- "(+ 1 (+ 2 35[)])"))
- (ert-info ("Insert state")
- (evil-test-buffer
- "(+ 1 (+ 2 3[)])"
- ("i" (kbd "C-u") (kbd "C-x C-e") [escape])
- "(+ 1 (+ 2 3[3]))"))
- (ert-info ("Emacs state")
- (evil-test-buffer
- "(+ 1 (+ 2 3[)])"
- ((kbd "C-z") (kbd "C-u") (kbd "C-x C-e"))
- "(+ 1 (+ 2 33[)])")))
-
-;;; ESC
-
-(ert-deftest evil-test-esc-count ()
- "Test if prefix-argument is transfered for key sequences with meta-key"
- :tags '(evil esc)
- (unless noninteractive
- (ert-info ("Test M-<right>")
- (evil-test-buffer
- "[A]BC DEF GHI JKL MNO"
- ("3" (kbd "ESC <right>"))
- "ABC DEF GHI[ ]JKL MNO"))
- (ert-info ("Test shell-command")
- (evil-test-buffer
- "[A]BC DEF GHI JKL MNO"
- ("1" (kbd "ESC !") "echo TEST" [return])
- "[T]EST\nABC DEF GHI JKL MNO"))))
-
-(when (or evil-tests-profiler evil-tests-run)
- (evil-tests-initialize))
-
-(ert-deftest evil-test-black-hole-register ()
- :tags '(evil)
- (ert-info ("Test \"_ on delete word")
- (evil-test-buffer
- "[E]vil evil is awesome."
- ("dw\"_dwP")
- "Evil[ ]is awesome."))
- (ert-info ("Test \"_ on delete line")
- (evil-test-buffer
- "[T]his line is a keeper!\nThis line is not."
- ("dd\"_ddP")
- "[T]his line is a keeper!"))
- (ert-info ("Test \"_ on delete region")
- (evil-test-buffer
- "<This region is a keeper>!\nThis line is not."
- ("d\gg\"_dGP")
- "This region is a keepe[r]")))
-
-(ert-deftest evil-test-pasteable-macros ()
- "Test if we can yank and paste macros containing
- <escape>"
- :tags '(evil)
- (ert-info ("Execute yanked macro")
- (evil-test-buffer
- "[i]foo\e"
- ("\"qd$@q\"qp"
- "fooifoo\e")))
- (ert-info ("Paste recorded marco")
- (evil-test-buffer
- ""
- (evil-set-register ?q (vconcat "ifoo" [escape]))
- ("@q\"qp")
- "fooifoo\e")))
-
-(ert-deftest evil-test-forward-symbol ()
- :tags '(evil)
- (ert-info ("Test symbol deletion")
- (evil-test-buffer
- "(test [t]his (hello there) with dao)"
- ("dao")
- "(test [(]hello there) with dao)"))
- (ert-info ("Test symbol motion")
- (evil-test-buffer
- "(test[ ](hello there) with dao)"
- (should (eq 0 (forward-evil-symbol 1)))
- "(test ([h]ello there) with dao)"
- (should (eq 0 (forward-evil-symbol 1)))
- "(test (hello[ ]there) with dao)"))
- (ert-info ("Test dio on whitespace")
- (evil-test-buffer
- "(test[ ]dio with whitespace)"
- ("dio")
- "(test[d]io with whitespace)"))
- (ert-info ("Test dao/dio with empty lines")
- (evil-test-buffer
- "there are two lines in this file\n[\n]and some whitespace between them"
- ("dao")
- "there are two lines in this file\n[a]nd some whitespace between them")
- (evil-test-buffer
- "here are another two lines\n[\n]with a blank line between them"
- ("dio")
- "here are another two lines\n[w]ith a blank line between them"))
- (ert-info ("Test dao/dio with empty lines and punctuation")
- (evil-test-buffer
- "These two lines \n[\n]!have punctuation on them"
- ("dao")
- "These two lines \n[!]have punctuation on them")))
-
-;; (ert-deftest evil-test-jump ()
-;; :tags '(evil jumps)
-;; (let ((evil--jumps-buffer-targets "\\*\\(new\\|scratch\\|test\\)\\*"))
-;; (ert-info ("Test jumping backward and forward in a single buffer")
-;; (evil-test-buffer
-;; "[z] z z z z z z z z z"
-;; ("/z" [return])
-;; "z [z] z z z z z z z z"
-;; ("nnnn")
-;; "z z z z z [z] z z z z"
-;; ("\C-o")
-;; "z z z z [z] z z z z z"
-;; ("\C-o")
-;; "z z z [z] z z z z z z"
-;; ("\C-i\C-i")
-;; "z z z z z [z] z z z z"))
-;; (ert-info ("Test jumping backward and forward across buffers")
-;; (evil-test-buffer
-;; "[z] z z z z z z z z z"
-;; (":new" [return] "inew buffer" [escape])
-;; "new buffe[r]"
-;; ("\C-o")
-;; "[z] z z z z z z z z z"
-;; ("\C-i")
-;; "new buffe[r]"))
-;; (ert-info ("Test jumping backward and forward with counts")
-;; (evil-test-buffer
-;; "[z] z z z z z z z z z"
-;; ("/z" [return] "nnnn")
-;; "z z z z z [z] z z z z"
-;; ("3\C-o")
-;; "z z [z] z z z z z z z"
-;; ("2\C-i")
-;; "z z z z [z] z z z z z"
-;; ))
-;; (ert-info ("Jump list branches off when new jump is set")
-;; (evil-test-buffer
-;; "[z] z z z z z z z"
-;; ("/z" [return] "nnnn4\C-o") ;; adds a bunch of jumps after the 2nd z
-;; "z [z] z z z z z z"
-;; ("/z" [return]) ;; sets a new jump, list should be reset
-;; "z z [z] z z z z z"
-;; ("\C-o")
-;; "z [z] z z z z z z"
-;; ("3\C-i") ;; even after jumping forward 3 times it can't get past
the 3rd z
-;; "z z [z] z z z z z"))))
-
-(ert-deftest evil-test-abbrev-expand ()
- :tags '(evil abbrev)
- (ert-info ("Test abbrev expansion on insert state exit")
- (define-abbrev-table 'global-abbrev-table
- '(("undef" "undefined"))) ;; add global abbrev
- (evil-test-buffer
- "foo unde[f] bar"
- ("a" [escape])
- "foo undefine[d] bar") ;; 'undef' should be expanded
- (evil-test-buffer
- "fo[o] undef bar"
- ("a" [escape])
- "fo[o] undef bar") ;; 'foo' shouldn't be expanded, it's not an abbrev
- (kill-all-abbrevs) ;; remove abbrevs
- (evil-test-buffer
- "foo unde[f] bar"
- ("a" [escape])
- "foo unde[f] bar") ;; 'undef' is not an abbrev, shouldn't be expanded
- (setq abbrevs-changed nil)))
-
-(ert-deftest evil-test-text-object-macro ()
- :tags '(evil abbrev)
- (ert-info ("Test pipe character and other delimiters as object delimiters")
- ;; This is the macro that broke after pull #747.
- (defmacro evil-test-define-and-bind-text-object (name key start-regex
end-regex)
- (let ((inner-name (make-symbol (concat "evil-inner-" name)))
- (outer-name (make-symbol (concat "evil-a-" name))))
- `(progn
- (evil-define-text-object ,inner-name (count &optional beg end type)
- (evil-select-paren ,start-regex ,end-regex beg end type count
nil))
- (evil-define-text-object ,outer-name (count &optional beg end type)
- (evil-select-paren ,start-regex ,end-regex beg end type count t))
- (define-key evil-inner-text-objects-map ,key #',inner-name)
- (define-key evil-outer-text-objects-map ,key #',outer-name))))
- (evil-test-define-and-bind-text-object "pipe" "|" "|" "|")
- (evil-test-define-and-bind-text-object "rackety" "#" "#|" "|#")
-
- (evil-test-buffer
- "#|this i[s] a test #|with rackety|# multiline
- and nestable comments|#"
- ("vi#")
- "#|<this is a test #|with rackety|# multiline
- and nestable comments>|#")
- (evil-test-buffer
- "| foo | aoe[u] | bar |"
- ("vi|")
- "| foo |< aoeu >| bar |"
- ("a|")
- "| foo <| aoeu |> bar |"
- ("a|")
- "<| foo | aoeu | bar |>")
- (evil-test-buffer
- "| foo | aoe[u] | bar |"
- ("ci|testing" [escape])
- "| foo |testing| bar |")))
-
-(provide 'evil-tests)
-
-;;; evil-tests.el ends here
- [nongnu] elpa/evil-goggles 838aacbe33 176/225: evil-goggles--show-p: check for a single char *and* single line, (continued)
- [nongnu] elpa/evil-goggles 838aacbe33 176/225: evil-goggles--show-p: check for a single char *and* single line, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 5780bcf8cb 186/225: Show hint only when the command is called interactively #18, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 4bfc8df8b3 191/225: Remove deprecated macros, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles bb974e38d2 193/225: Add hints for `J`, `gq` and `=`, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 42051e2cb3 197/225: Keep configuration per command in a variable, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 1c72501a6f 196/225: Reduce configuration options - drop `substitute`, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 2b922512fb 199/225: Refactor, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles dac6c45aa1 214/225: Add hint for `Y', when `evil-want-Y-yank-to-eol' is t, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles bf1be3be24 018/225: Don't show overlay on whitespaces-only regions, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 36fb70d6a1 044/225: Rename option `evil-goggles-show-for` to `evil-goggles-duration`, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles c6935dc53d 099/225: Don't bundle evil-tests.el. Fix #15,
ELPA Syncer <=
- [nongnu] elpa/evil-goggles 88cb3ffa38 100/225: Fetch evil-tests.el from evil's repo. Comment out parts of it with sed. Refs #15, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 2d2011180f 111/225: Mention experimental pulse option in README, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles e9b0ed0484 137/225: Tweak defaults, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles ca6b5f7bfe 138/225: Rename APIs pre/post to blocking/async, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles df26adb069 153/225: Use async hints for paste, undo/redo, set mark, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 692f276434 158/225: Indentation, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 9626b143e1 171/225: Always use `evaporate` overlay property, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 56691c6e65 132/225: Rename functions, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles 48feeba6f0 180/225: Update README, ELPA Syncer, 2022/01/12
- [nongnu] elpa/evil-goggles bc318ad4b7 184/225: `require` pulse, rather than create an autoload for one of its functions, ELPA Syncer, 2022/01/12