[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] map 89baf16 2/2: * test/automated/map-tests.el: Refactorin
|
From: |
Nicolas Petton |
|
Subject: |
[Emacs-diffs] map 89baf16 2/2: * test/automated/map-tests.el: Refactoring of test methods. |
|
Date: |
Tue, 21 Apr 2015 18:54:57 +0000 |
branch: map
commit 89baf163324c6820ca17e91cda9dc8b162a59eab
Author: Nicolas Petton <address@hidden>
Commit: Nicolas Petton <address@hidden>
* test/automated/map-tests.el: Refactoring of test methods.
---
test/automated/map-tests.el | 284 ++++++++++++++++++++----------------------
1 files changed, 135 insertions(+), 149 deletions(-)
diff --git a/test/automated/map-tests.el b/test/automated/map-tests.el
index ea7b0af..9a0d99e 100644
--- a/test/automated/map-tests.el
+++ b/test/automated/map-tests.el
@@ -29,56 +29,56 @@
(require 'ert)
(require 'map)
-(defmacro with-maps-do (alist-name vec-name ht-name &rest body)
- (declare (indent 3))
- `(let ((,alist-name '((a . 2)
- (b . 3)
- (c . 4)))
- (,vec-name (make-vector 3 nil))
- (,ht-name (make-hash-table)))
- (aset ,vec-name 0 'a)
- (aset ,vec-name 1 'b)
- (aset ,vec-name 2 'c)
- (puthash 'a 2 ,ht-name)
- (puthash 'b 3 ,ht-name)
- (puthash 'c 4 ,ht-name)
- (progn
- ,@body)))
+(defmacro with-maps-do (var &rest body)
+ "Successively bind VAR to an alist, vector and hash-table.
+Each map is built from the following alist data:
+'((0 . 3) (1 . 4) (2 . 5)).
+Evaluate BODY for each created map.
+
+\(fn (var map) body)"
+ (declare (indent 1) (debug t))
+ (let ((alist (make-symbol "alist"))
+ (vec (make-symbol "vec"))
+ (ht (make-symbol "ht")))
+ `(let ((,alist '((0 . 3)
+ (1 . 4)
+ (2 . 5)))
+ (,vec (make-vector 3 nil))
+ (,ht (make-hash-table)))
+ (aset ,vec 0 '3)
+ (aset ,vec 1 '4)
+ (aset ,vec 2 '5)
+ (puthash '0 3 ,ht)
+ (puthash '1 4 ,ht)
+ (puthash '2 5 ,ht)
+ (dolist (,var (list ,alist ,vec ,ht))
+ ,@body))))
(ert-deftest test-map-elt ()
- (with-maps-do alist vec ht
- (assert (= 2 (map-elt alist 'a)))
- (assert (= 3 (map-elt alist 'b)))
- (assert (= 4 (map-elt alist 'c)))
- (assert (null (map-elt alist 'd)))
- (assert (= 2 (map-elt ht 'a)))
- (assert (= 3 (map-elt ht 'b)))
- (assert (= 4 (map-elt ht 'c)))
- (assert (null (map-elt ht 'd)))
- (assert (eq 'a (map-elt vec 0)))
- (assert (eq 'b (map-elt vec 1)))
- (assert (eq 'c (map-elt vec 2)))
- (assert (null (map-elt vec 3)))))
+ (with-maps-do map
+ (assert (= 3 (map-elt map 0)))
+ (assert (= 4 (map-elt map 1)))
+ (assert (= 5 (map-elt map 2)))
+ (assert (null (map-elt map 4)))))
(ert-deftest test-map-elt-default ()
- (with-maps-do alist vec ht
- (assert (= 5 (map-elt alist 'd 5)))
- (assert (= 5 (map-elt vec 4 5)))
- (assert (= 5 (map-elt ht 'd 5)))))
+ (with-maps-do map
+ (assert (= 5 (map-elt map 7 5)))))
(ert-deftest test-map-put ()
- (with-maps-do alist vec ht
- (map-put alist 'd 4)
- (assert (= (map-elt alist 'd) 4))
- (map-put alist 'd 5)
- (assert (= (map-elt alist 'd) 5))
- (map-put ht 'd 4)
- (assert (= (map-elt ht 'd) 4))
- (map-put ht 'd 5)
- (assert (= (map-elt ht 'd) 5))
- (map-put vec 0 'd)
- (assert (eq (map-elt vec 0) 'd))
- (should-error (map-put vec 4 'd))))
+ (with-maps-do map
+ (map-put map 2 'hello)
+ (assert (eq (map-elt map 2) 'hello)))
+ (let ((ht (make-hash-table)))
+ (map-put ht 2 'a)
+ (assert (eq (map-elt ht 2)
+ 'a)))
+ (let ((alist '((0 . a) (1 . b) (2 . c))))
+ (map-put alist 2 'a)
+ (assert (eq (map-elt alist 2)
+ 'a)))
+ (let ((vec [3 4 5]))
+ (should-error (map-put vec 3 6))))
(ert-deftest test-map-put-literal ()
(assert (= (map-elt (map-put [1 2 3] 1 4) 1)
@@ -93,13 +93,9 @@
(assert (eq (map-put ht 'a 'hello) ht))))
(ert-deftest test-map-delete ()
- (with-maps-do alist vec ht
- (map-delete alist 'a)
- (assert (null (map-elt alist 'a)))
- (map-delete ht 'a)
- (assert (null (map-elt ht 'a)))
- (map-delete vec 2)
- (assert (null (map-elt vec 2)))))
+ (with-maps-do map
+ (map-delete map 1)
+ (assert (null (map-elt map 1)))))
(ert-deftest test-map-delete-return-value ()
(let ((ht (make-hash-table)))
@@ -136,32 +132,24 @@
(assert (map-p [1 2 3]))
(assert (map-p (make-hash-table)))
(assert (map-p "hello"))
- (with-maps-do alist vec ht
- (assert (map-p alist))
- (assert (map-p vec))
- (assert (map-p ht))
- (assert (not (map-p 1)))
- (assert (not (map-p 'hello)))))
+ (assert (not (map-p 1)))
+ (assert (not (map-p 'hello))))
(ert-deftest test-map-keys ()
- (with-maps-do alist vec ht
- (assert (equal (map-keys alist) '(a b c)))
- (assert (equal (map-keys vec) '(0 1 2)))
- (assert (equal (map-keys ht) '(a b c)))))
+ (with-maps-do map
+ (assert (equal (map-keys map) '(0 1 2))))
+ (assert (null (map-keys nil)))
+ (assert (null (map-keys []))))
(ert-deftest test-map-values ()
- (with-maps-do alist vec ht
- (assert (equal (map-values alist) '(2 3 4)))
- (assert (equal (map-values vec) '(a b c)))
- (assert (equal (map-values ht) '(2 3 4)))))
+ (with-maps-do map
+ (assert (equal (map-values map) '(3 4 5)))))
(ert-deftest test-map-pairs ()
- (with-maps-do alist vec ht
- (assert (equal (map-pairs alist) alist))
- (assert (equal (map-pairs vec) '((0 . a)
- (1 . b)
- (2 . c))))
- (assert (equal (map-pairs ht) alist))))
+ (with-maps-do map
+ (assert (equal (map-pairs map) '((0 . 3)
+ (1 . 4)
+ (2 . 5))))))
(ert-deftest test-map-length ()
(let ((ht (make-hash-table)))
@@ -177,19 +165,18 @@
(assert (= 4 (map-length ht)))))
(ert-deftest test-map-copy ()
- (with-maps-do alist vec ht
- (dolist (map (list alist vec ht))
- (let ((copy (map-copy map)))
- (assert (equal (map-keys map) (map-keys copy)))
- (assert (equal (map-values map) (map-values copy)))
- (assert (not (eq map copy)))))))
+ (with-maps-do map
+ (let ((copy (map-copy map)))
+ (assert (equal (map-keys map) (map-keys copy)))
+ (assert (equal (map-values map) (map-values copy)))
+ (assert (not (eq map copy))))))
(ert-deftest test-map-apply ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-apply (lambda (k v) (cons (symbol-name k) v))
- map)
- '(("a" . 2) ("b" . 3) ("c" . 4)))))
+ (with-maps-do map
+ (assert (equal (map-apply (lambda (k v) (cons (int-to-string k) v))
+ map)
+ '(("0" . 3) ("1" . 4) ("2" . 5)))))
+ (let ((vec [a b c]))
(assert (equal (map-apply (lambda (k v) (cons (1+ k) v))
vec)
'((1 . a)
@@ -197,64 +184,62 @@
(3 . c))))))
(ert-deftest test-map-keys-apply ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-keys-apply (lambda (k) (symbol-name k))
- map)
- '("a" "b" "c"))))
+ (with-maps-do map
+ (assert (equal (map-keys-apply (lambda (k) (int-to-string k))
+ map)
+ '("0" "1" "2"))))
+ (let ((vec [a b c]))
(assert (equal (map-keys-apply (lambda (k) (1+ k))
- vec)
+ vec)
'(1 2 3)))))
(ert-deftest test-map-values-apply ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-values-apply (lambda (v) (1+ v))
- map)
- '(3 4 5))))
+ (with-maps-do map
+ (assert (equal (map-values-apply (lambda (v) (1+ v))
+ map)
+ '(4 5 6))))
+ (let ((vec [a b c]))
(assert (equal (map-values-apply (lambda (v) (symbol-name v))
- vec)
+ vec)
'("a" "b" "c")))))
(ert-deftest test-map-filter ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-keys (map-filter (lambda (k v)
- (<= 3 v))
- map))
- '(b c)))
- (assert (null (map-filter (lambda (k v)
- (eq 'd k))
- map))))
+ (with-maps-do map
+ (assert (equal (map-keys (map-filter (lambda (k v)
+ (<= 4 v))
+ map))
+ '(1 2)))
(assert (null (map-filter (lambda (k v)
- (eq 3 v))
- [1 2 4 5])))
- (assert (equal (map-filter (lambda (k v)
- (eq 3 k))
- [1 2 4 5])
- '((3 . 5))))))
+ (eq 'd k))
+ map))))
+ (assert (null (map-filter (lambda (k v)
+ (eq 3 v))
+ [1 2 4 5])))
+ (assert (equal (map-filter (lambda (k v)
+ (eq 3 k))
+ [1 2 4 5])
+ '((3 . 5)))))
(ert-deftest test-map-remove ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-keys (map-remove (lambda (k v)
- (<= 3 v))
- map))
- '(a)))
- (assert (equal (map-keys (map-remove (lambda (k v)
- (eq 'd k))
- map))
- (map-keys map))))
- (assert (equal (map-remove (lambda (k v)
- (eq 3 v))
- [1 2 4 5])
- '((0 . 1)
- (1 . 2)
- (2 . 4)
- (3 . 5))))
- (assert (null (map-remove (lambda (k v)
- (>= k 0))
- [1 2 4 5])))))
+ (with-maps-do map
+ (assert (equal (map-keys (map-remove (lambda (k v)
+ (>= v 4))
+ map))
+ '(0)))
+ (assert (equal (map-keys (map-remove (lambda (k v)
+ (eq 'd k))
+ map))
+ (map-keys map))))
+ (assert (equal (map-remove (lambda (k v)
+ (eq 3 v))
+ [1 2 4 5])
+ '((0 . 1)
+ (1 . 2)
+ (2 . 4)
+ (3 . 5))))
+ (assert (null (map-remove (lambda (k v)
+ (>= k 0))
+ [1 2 4 5]))))
(ert-deftest test-map-empty-p ()
(assert (map-empty-p nil))
@@ -274,15 +259,15 @@
(assert (not (map-contains-key-p [a b c] 3))))
(ert-deftest test-map-some-p ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht))
- (assert (equal (map-some-p (lambda (k v)
- (eq 'a k))
- map)
- (cons 'a 2)))
- (assert (not (map-some-p (lambda (k v)
- (eq 'd k))
- map))))
+ (with-maps-do map
+ (assert (equal (map-some-p (lambda (k v)
+ (eq 1 k))
+ map)
+ (cons 1 4)))
+ (assert (not (map-some-p (lambda (k v)
+ (eq 'd k))
+ map))))
+ (let ((vec [a b c]))
(assert (equal (map-some-p (lambda (k v)
(> k 1))
vec)
@@ -292,24 +277,25 @@
vec)))))
(ert-deftest test-map-every-p ()
- (with-maps-do alist vec ht
- (dolist (map (list alist ht vec))
- (assert (map-every-p (lambda (k v)
- k)
- map))
- (assert (not (map-every-p (lambda (k v)
- nil)
- map))))
+ (with-maps-do map
+ (assert (map-every-p (lambda (k v)
+ k)
+ map))
+ (assert (not (map-every-p (lambda (k v)
+ nil)
+ map))))
+ (let ((vec [a b c]))
(assert (map-every-p (lambda (k v)
(>= k 0))
vec))
(assert (not (map-every-p (lambda (k v)
- (> k 3))
+ (> k 3))
vec)))))
(ert-deftest test-map-into ()
- (with-maps-do alist vec ht
- (assert (hash-table-p (map-into alist 'hash-table)))
+ (let* ((alist '((a . 1) (b . 2)))
+ (ht (map-into alist 'hash-table)))
+ (assert (hash-table-p ht))
(assert (equal (map-into (map-into alist 'hash-table) 'list)
alist))
(assert (listp (map-into ht 'list)))