lem/tests/input.lisp at main · lem-project/lem · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
(defpackage :lem-tests/input
  (:use :cl :rove :lem))
(in-package :lem-tests/input)

(deftest keys-equal-p-test
  (ok (lem-core::keys-equal-p (make-key :sym "x") (make-key :sym "x")))
  (ok (lem-core::keys-equal-p (make-key :ctrl t :sym "c") (make-key :ctrl t :sym "c")))
  (ng (lem-core::keys-equal-p (make-key :sym "x") (make-key :sym "y")))
  (ng (lem-core::keys-equal-p (make-key :ctrl t :sym "c") (make-key :sym "c"))))

(deftest meta-prefix-key-p-with-t-test
  (ok (lem-core::meta-prefix-key-p (make-key :sym "Escape") t))
  (ng (lem-core::meta-prefix-key-p (make-key :sym "x") t))
  (ng (lem-core::meta-prefix-key-p (make-key :meta t :sym "Escape") t)))

(deftest meta-prefix-key-p-with-single-key-test
  ;; Note: C-[ is converted to Escape by Lem's key conversion, so we use C-; instead
  (let ((prefix-key (make-key :ctrl t :sym ";")))
    (ok (lem-core::meta-prefix-key-p (make-key :ctrl t :sym ";") prefix-key))
    (ng (lem-core::meta-prefix-key-p (make-key :sym "Escape") prefix-key))
    (ng (lem-core::meta-prefix-key-p (make-key :sym "x") prefix-key))))

(deftest meta-prefix-key-p-with-key-list-test
  (let ((prefix-keys (list (make-key :sym "Escape")
                           (make-key :ctrl t :sym ";"))))
    (ok (lem-core::meta-prefix-key-p (make-key :sym "Escape") prefix-keys))
    (ok (lem-core::meta-prefix-key-p (make-key :ctrl t :sym ";") prefix-keys))
    (ng (lem-core::meta-prefix-key-p (make-key :sym "x") prefix-keys))))

(deftest add-meta-modifier-test
  (let ((key (lem-core::add-meta-modifier (make-key :sym "x"))))
    (ok (key-meta key))
    (ok (equal "x" (key-sym key))))
  (let ((key (lem-core::add-meta-modifier (make-key :ctrl t :sym "c"))))
    (ok (key-meta key))
    (ok (key-ctrl key))
    (ok (equal "c" (key-sym key)))))

(deftest meta-prefix-disabled-test
  (lem/common/var:with-global-variable-value (meta-prefix-keys nil)
    (let ((escape-key (make-key :sym "Escape"))
          (x-key (make-key :sym "x")))
      (let ((result (lem-core::maybe-convert-to-meta
                     escape-key
                     (lambda () x-key))))
        (ok (match-key result :sym "Escape"))))))

(deftest meta-prefix-with-t-test
  (lem/common/var:with-global-variable-value (meta-prefix-keys t)
    (let ((escape-key (make-key :sym "Escape"))
          (x-key (make-key :sym "x")))
      (let ((result (lem-core::maybe-convert-to-meta
                     escape-key
                     (lambda () x-key))))
        (ok (key-meta result))
        (ok (equal "x" (key-sym result)))))))

(deftest meta-prefix-double-press-test
  (lem/common/var:with-global-variable-value (meta-prefix-keys t)
    (let ((escape-key (make-key :sym "Escape")))
      (let ((result (lem-core::maybe-convert-to-meta
                     escape-key
                     (lambda () escape-key))))
        (ok (match-key result :sym "Escape"))
        (ng (key-meta result))))))

(deftest meta-prefix-preserves-modifiers-test
  (lem/common/var:with-global-variable-value (meta-prefix-keys t)
    (let ((escape-key (make-key :sym "Escape"))
          (ctrl-c-key (make-key :ctrl t :sym "c")))
      (let ((result (lem-core::maybe-convert-to-meta
                     escape-key
                     (lambda () ctrl-c-key))))
        (ok (key-meta result))
        (ok (key-ctrl result))
        (ok (equal "c" (key-sym result)))))))

(deftest non-prefix-key-passes-through-test
  (lem/common/var:with-global-variable-value (meta-prefix-keys t)
    (let ((x-key (make-key :sym "x")))
      (let ((result (lem-core::maybe-convert-to-meta
                     x-key
                     (lambda () (error "Should not be called")))))
        (ok (match-key result :sym "x"))))))

(deftest custom-prefix-key-test
  ;; Note: C-[ is converted to Escape by Lem's key conversion, so we use C-; instead
  (let ((custom-key (make-key :ctrl t :sym ";")))
    (lem/common/var:with-global-variable-value (meta-prefix-keys custom-key)
      (let ((x-key (make-key :sym "x")))
        ;; C-; + x -> M-x
        (let ((result (lem-core::maybe-convert-to-meta
                       custom-key
                       (lambda () x-key))))
          (ok (key-meta result))
          (ok (equal "x" (key-sym result))))
        ;; Escape should not trigger with custom key
        (let ((escape-key (make-key :sym "Escape")))
          (let ((result (lem-core::maybe-convert-to-meta
                         escape-key
                         (lambda () (error "Should not be called")))))
            (ok (match-key result :sym "Escape"))))))))

(deftest multiple-prefix-keys-test
  ;; Note: C-[ is converted to Escape by Lem's key conversion, so we use C-; instead
  (let ((prefix-keys (list (make-key :sym "Escape")
                           (make-key :ctrl t :sym ";"))))
    (lem/common/var:with-global-variable-value (meta-prefix-keys prefix-keys)
      (let ((x-key (make-key :sym "x")))
        ;; Escape + x -> M-x
        (let ((result (lem-core::maybe-convert-to-meta
                       (make-key :sym "Escape")
                       (lambda () x-key))))
          (ok (key-meta result))
          (ok (equal "x" (key-sym result))))
        ;; C-; + x -> M-x
        (let ((result (lem-core::maybe-convert-to-meta
                       (make-key :ctrl t :sym ";")
                       (lambda () x-key))))
          (ok (key-meta result))
          (ok (equal "x" (key-sym result))))))))