1 ;;; map-tests.el --- Tests for map.el -*- lexical-binding:t -*-
3 ;; Copyright (C) 2015-2016 Free Software Foundation, Inc.
5 ;; Author: Nicolas Petton <nicolas@petton.fr>
6 ;; Maintainer: emacs-devel@gnu.org
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software: you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
32 (defmacro with-maps-do
(var &rest body
)
33 "Successively bind VAR to an alist, vector and hash-table.
34 Each map is built from the following alist data:
35 '((0 . 3) (1 . 4) (2 . 5)).
36 Evaluate BODY for each created map.
39 (declare (indent 1) (debug t
))
40 (let ((alist (make-symbol "alist"))
41 (vec (make-symbol "vec"))
42 (ht (make-symbol "ht")))
43 `(let ((,alist
(list (cons 0 3)
47 (,ht
(make-hash-table)))
51 (dolist (,var
(list ,alist
,vec
,ht
))
54 (ert-deftest test-map-elt
()
56 (should (= 3 (map-elt map
0)))
57 (should (= 4 (map-elt map
1)))
58 (should (= 5 (map-elt map
2)))
59 (should (null (map-elt map -
1)))
60 (should (null (map-elt map
4)))))
62 (ert-deftest test-map-elt-default
()
64 (should (= 5 (map-elt map
7 5)))))
66 (ert-deftest test-map-elt-with-nil-value
()
67 (should (null (map-elt '((a .
1)
72 (ert-deftest test-map-put
()
74 (setf (map-elt map
2) 'hello
)
75 (should (eq (map-elt map
2) 'hello
)))
77 (map-put map
2 'hello
)
78 (should (eq (map-elt map
2) 'hello
)))
79 (let ((ht (make-hash-table)))
80 (setf (map-elt ht
2) 'a
)
81 (should (eq (map-elt ht
2)
83 (let ((alist '((0 . a
) (1 . b
) (2 . c
))))
84 (setf (map-elt alist
2) 'a
)
85 (should (eq (map-elt alist
2)
88 (should-error (setf (map-elt vec
3) 6))))
90 (ert-deftest test-map-put-alist-new-key
()
91 "Regression test for Bug#23105."
92 (let ((alist '((0 . a
))))
94 (should (eq (map-elt alist
2)
97 (ert-deftest test-map-put-return-value
()
98 (let ((ht (make-hash-table)))
99 (should (eq (map-put ht
'a
'hello
) 'hello
))))
101 (ert-deftest test-map-delete
()
104 (should (null (map-elt map
1))))
107 (should (null (map-elt map -
2)))))
109 (ert-deftest test-map-delete-return-value
()
110 (let ((ht (make-hash-table)))
111 (should (eq (map-delete ht
'a
) ht
))))
113 (ert-deftest test-map-nested-elt
()
114 (let ((vec [a b
[c d
[e f
]]]))
115 (should (eq (map-nested-elt vec
'(2 2 0)) 'e
)))
116 (let ((alist '((a .
1)
121 (should (eq (map-nested-elt alist
'(b e f
))
123 (let ((ht (make-hash-table)))
124 (setf (map-elt ht
'a
) 1)
125 (setf (map-elt ht
'b
) (make-hash-table))
126 (setf (map-elt (map-elt ht
'b
) 'c
) 2)
127 (should (eq (map-nested-elt ht
'(b c
))
130 (ert-deftest test-map-nested-elt-default
()
131 (let ((vec [a b
[c d
]]))
132 (should (null (map-nested-elt vec
'(2 3))))
133 (should (null (map-nested-elt vec
'(2 1 1))))
134 (should (= 4 (map-nested-elt vec
'(2 1 1) 4)))))
136 (ert-deftest test-mapp
()
138 (should (mapp '((a . b
) (c . d
))))
139 (should (mapp '(a b c d
)))
141 (should (mapp [1 2 3]))
142 (should (mapp (make-hash-table)))
143 (should (mapp "hello"))
144 (should (not (mapp 1)))
145 (should (not (mapp 'hello
))))
147 (ert-deftest test-map-keys
()
149 (should (equal (map-keys map
) '(0 1 2))))
150 (should (null (map-keys nil
)))
151 (should (null (map-keys []))))
153 (ert-deftest test-map-values
()
155 (should (equal (map-values map
) '(3 4 5)))))
157 (ert-deftest test-map-pairs
()
159 (should (equal (map-pairs map
) '((0 .
3)
163 (ert-deftest test-map-length
()
164 (let ((ht (make-hash-table)))
169 (should (= 0 (map-length nil
)))
170 (should (= 0 (map-length [])))
171 (should (= 0 (map-length (make-hash-table))))
172 (should (= 5 (map-length [0 1 2 3 4])))
173 (should (= 2 (map-length '((a .
1) (b .
2)))))
174 (should (= 4 (map-length ht
)))))
176 (ert-deftest test-map-copy
()
178 (let ((copy (map-copy map
)))
179 (should (equal (map-keys map
) (map-keys copy
)))
180 (should (equal (map-values map
) (map-values copy
)))
181 (should (not (eq map copy
))))))
183 (ert-deftest test-map-apply
()
185 (should (equal (map-apply (lambda (k v
) (cons (int-to-string k
) v
))
187 '(("0" .
3) ("1" .
4) ("2" .
5)))))
189 (should (equal (map-apply (lambda (k v
) (cons (1+ k
) v
))
195 (ert-deftest test-map-keys-apply
()
197 (should (equal (map-keys-apply (lambda (k) (int-to-string k
))
201 (should (equal (map-keys-apply (lambda (k) (1+ k
))
205 (ert-deftest test-map-values-apply
()
207 (should (equal (map-values-apply (lambda (v) (1+ v
))
211 (should (equal (map-values-apply (lambda (v) (symbol-name v
))
215 (ert-deftest test-map-filter
()
217 (should (equal (map-keys (map-filter (lambda (_k v
)
221 (should (null (map-filter (lambda (k _v
)
224 (should (null (map-filter (lambda (_k v
)
227 (should (equal (map-filter (lambda (k _v
)
232 (ert-deftest test-map-remove
()
234 (should (equal (map-keys (map-remove (lambda (_k v
)
238 (should (equal (map-keys (map-remove (lambda (k _v
)
242 (should (equal (map-remove (lambda (_k v
)
249 (should (null (map-remove (lambda (k _v
)
253 (ert-deftest test-map-empty-p
()
254 (should (map-empty-p nil
))
255 (should (not (map-empty-p '((a . b
) (c . d
)))))
256 (should (map-empty-p []))
257 (should (not (map-empty-p [1 2 3])))
258 (should (map-empty-p (make-hash-table)))
259 (should (not (map-empty-p "hello")))
260 (should (map-empty-p "")))
262 (ert-deftest test-map-contains-key
()
263 (should (map-contains-key '((a .
1) (b .
2)) 'a
))
264 (should (not (map-contains-key '((a .
1) (b .
2)) 'c
)))
265 (should (map-contains-key '(("a" .
1)) "a"))
266 (should (not (map-contains-key '(("a" .
1)) "a" #'eq
)))
267 (should (map-contains-key [a b c
] 2))
268 (should (not (map-contains-key [a b c
] 3))))
270 (ert-deftest test-map-some
()
272 (should (map-some (lambda (k _v
)
275 (should-not (map-some (lambda (k _v
)
279 (should (map-some (lambda (k _v
)
282 (should-not (map-some (lambda (k _v
)
286 (ert-deftest test-map-every-p
()
288 (should (map-every-p (lambda (k _v
)
291 (should (not (map-every-p (lambda (_k _v
)
295 (should (map-every-p (lambda (k _v
)
298 (should (not (map-every-p (lambda (k _v
)
302 (ert-deftest test-map-into
()
303 (let* ((alist '((a .
1) (b .
2)))
304 (ht (map-into alist
'hash-table
)))
305 (should (hash-table-p ht
))
306 (should (equal (map-into (map-into alist
'hash-table
) 'list
)
308 (should (listp (map-into ht
'list
)))
309 (should (equal (map-keys (map-into (map-into ht
'list
) 'hash-table
))
311 (should (equal (map-values (map-into (map-into ht
'list
) 'hash-table
))
313 (should (null (map-into nil
'list
)))
314 (should (map-empty-p (map-into nil
'hash-table
)))
315 (should-error (map-into [1 2 3] 'string
))))
317 (ert-deftest test-map-let
()
318 (map-let (foo bar baz
) '((foo .
1) (bar .
2))
325 '((foo .
1) (bar .
2))
330 (ert-deftest test-map-merge-with
()
331 (should (equal (map-merge-with 'list
#'+
334 '((1 .
1) (2 .
5) (3 .
0)))
335 '((3 .
0) (2 .
9) (1 .
6)))))
338 ;;; map-tests.el ends here