spacemacs/core/tests/core-evilify-keymap-utest.el

;;; core-evilify-keymap-utest.el --- Spacemacs Unit Test File
;;
;; Copyright (c) 2012-2014 Sylvain Benner
;; Copyright (c) 2014-2015 Sylvain Benner & Contributors
;;
;; Author: Sylvain Benner <sylvain.benner@gmail.com>
;; URL: https://github.com/syl20bnr/spacemacs
;;
;; This file is not part of GNU Emacs.
;;
;;; License: GPLv3
(require 'mocker)
(require 'core-evilify-keymap)

;; ---------------------------------------------------------------------------
;; spacemacs//evilify-entry-func
;; ---------------------------------------------------------------------------

;; full keymap

(ert-deftest test-evilify-keymap-entry-func--full-keymap ()
  (let ((map (make-keymap)))
    (should (eq 'spacemacs//evilify-char-table
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) nil)))))

;; command

(ert-deftest test-evilify-keymap-entry-func--command-s ()
  (let ((map (make-sparse-keymap)))
    (define-key map "s" 'func)
    (should (eq 'spacemacs//evilify-ascii-event-command-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?s))))))

(ert-deftest test-evilify-keymap-entry-func--command-S ()
  (let ((map (make-sparse-keymap)))
    (define-key map "S" 'func)
    (should (eq 'spacemacs//evilify-ascii-event-command-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?S))))))

(ert-deftest test-evilify-keymap-entry-func--command-C-s ()
  (let ((map (make-sparse-keymap))
        (ekeys (list (string-to-char "\C-s"))))
    (define-key map (kbd "C-s") 'func)
    (should (eq 'spacemacs//evilify-ascii-event-command-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

(ert-deftest test-evilify-keymap-entry-func--command-C-S-s ()
  (let ((map (make-sparse-keymap))
        (ekeys (list (+ (expt 2 25) (string-to-char "\C-s")))))
    (define-key map (kbd "C-S-s") 'func)
    (should (eq 'spacemacs//evilify-shift-ascii-event
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

;; keymap

(ert-deftest test-evilify-keymap-entry-func--keymap-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "s" submap)
    (should (eq 'spacemacs//evilify-ascii-event-keymap-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?s))))))

(ert-deftest test-evilify-keymap-entry-func--keymap-S ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "S" submap)
    (should (eq 'spacemacs//evilify-ascii-event-keymap-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?S))))))

(ert-deftest test-evilify-keymap-entry-func--keymap-C-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap))
        (ekeys (list (string-to-char "\C-s"))))
    (define-key map (kbd "C-s") submap)
    (should (eq 'spacemacs//evilify-ascii-event-keymap-binding
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

(ert-deftest test-evilify-keymap-entry-func--keymap-C-S-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap))
        (ekeys (list (+ (expt 2 25) (string-to-char "\C-s")))))
    (define-key map (kbd "C-S-s") submap)
    (should (eq 'spacemacs//evilify-shift-ascii-event
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

(ert-deftest test-evilify-keymap-entry-func--ignore-lambda-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "s" (lambda () (interactive) 'dummy))
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?s))))))

;; ignore lambdas

(ert-deftest test-evilify-keymap-entry-func--ignore-lambda-S ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "S" (lambda () (interactive) 'dummy))
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?S))))))

(ert-deftest test-evilify-keymap-entry-func--ignore-lambda-C-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap))
        (ekeys (list (string-to-char "\C-s"))))
    (define-key map (kbd "C-s") (lambda () (interactive) 'dummy))
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

(ert-deftest test-evilify-keymap-entry-func--ignore-lambda-C-S-s ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap))
        (ekeys (list (+ (expt 2 25) (string-to-char "\C-s")))))
    (define-key map (kbd "C-S-s") (lambda () (interactive) 'dummy))
    (should (eq 'spacemacs//evilify-shift-ascii-event
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) ekeys)))))

;; remap

(ert-deftest test-evilify-keymap-entry-func--ignore-remap ()
  (let ((map (make-sparse-keymap)))
    (define-key map "s" 'func)
    (define-key map [remap func] 'func2)
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) '(?s))))))

;; not evilified

(ert-deftest test-evilify-keymap-entry-func--ignore-command-s-not-evilified ()
  (let ((map (make-sparse-keymap)))
    (define-key map "s" 'func)
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) nil)))))

(ert-deftest test-evilify-keymap-entry-func--ignore-keymap-s-not-evilified ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "s" submap)
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) nil)))))

(ert-deftest test-evilify-keymap-entry-func--ignore-lambda-s-not-evilified ()
  (let ((map (make-sparse-keymap))
        (submap (make-sparse-keymap)))
    (define-key map "s" (lambda () (interactive) 'dummy))
    (should (eq 'ignore
                (spacemacs//evilify-entry-func (nth 0 (cdr map)) nil)))))


;; ---------------------------------------------------------------------------
;; spacemacs//evilify-ascii-event-command-binding
;; ---------------------------------------------------------------------------



;; TO UPDATE

;; (ert-deftest test-evilify-choose-rebind-event--h-to-H ()
;;   (let* ((event ?h)
;;          (map (let ((keymap (make-sparse-keymap)))
;;                 (define-key keymap "h" 'ignore)
;;                 keymap))
;;          (result (spacemacs//evilify-next-event map event)))
;;     (should (equal ?H result))))

;; (ert-deftest test-evilify-choose-rebind-event--h-to-C-h ()
;;   (let* ((event ?h)
;;          (map (let ((keymap (make-sparse-keymap)))
;;                 (define-key keymap "h" 'ignore)
;;                 (define-key keymap "H" 'ignore)
;;                 keymap))
;;          (result (spacemacs//evilify-next-event map event)))
;;     (should (equal (string-to-char "\C-h") result))))

;; (ert-deftest test-evilify-choose-rebind-event--h-to-C-H ()
;;   (let* ((event ?h)
;;          (map (let ((keymap (make-sparse-keymap)))
;;                 (define-key keymap "h" 'ignore)
;;                 (define-key keymap "H" 'ignore)
;;                 (define-key keymap (kbd "C-h") 'ignore)
;;                 keymap))
;;          (result (spacemacs//evilify-next-event map event)))
;;     (should (equal (aref (kbd "C-S-H") 0) result))))

;; (ert-deftest test-evilify-choose-rebind-event--h-to-nil ()
;;   (let* ((event ?h)
;;          (map (let ((keymap (make-sparse-keymap)))
;;                 (define-key keymap "h" 'ignore)
;;                 (define-key keymap "H" 'ignore)
;;                 (define-key keymap (kbd "C-h") 'ignore)
;;                 (define-key keymap (kbd "C-S-h") 'ignore)
;;                 keymap))
;;          (result (spacemacs//evilify-next-event map event)))
;;     (should (equal nil result))))