tests/test-elmo-util.el

   1 ;; -*- lexical-binding: t -*-
   2 (require 'lunit)
   3 (require 'elmo-util)
   4
   5 (luna-define-class test-elmo-util (lunit-test-case))
   6
   7 ;; setup & teardown
   8 (defvar test-elmo-temoporary-file)
   9
  10 (luna-define-method lunit-test-case-setup ((case test-elmo-util))
  11   (setq test-elmo-temoporary-file
  12         (make-temp-file temporary-file-directory)))
  13
  14 (luna-define-method lunit-test-case-teardown ((case test-elmo-util))
  15   (when (file-exists-p test-elmo-temoporary-file)
  16     (delete-file test-elmo-temoporary-file)))
  17
  18
  19 (luna-define-method test-elmo-replace-string-as-filename-1 ((case test-elmo-util))
  20   "Revert checking replace and recover."
  21   (lunit-assert
  22    (let ((str "/foo//./../bar/"))
  23      (string= str
  24               (elmo-recover-string-from-filename
  25                (elmo-replace-string-as-filename str))))))
  26
  27
  28 ;; object save & load
  29 (luna-define-method test-elmo-object-save-1 ((case test-elmo-util))
  30   "Check `print-length' let bindings."
  31   (let ((list '(1 2 3 4 5 6 7 8 9 10 11 12))
  32         (print-length 1))
  33     (elmo-object-save test-elmo-temoporary-file list)
  34     (lunit-assert
  35      (equal list
  36             (elmo-object-load test-elmo-temoporary-file)))))
  37
  38 (luna-define-method test-elmo-object-save-2 ((case test-elmo-util))
  39   "Check `print-level' let bindings."
  40   (let ((list '(1 (2 :foo (nil . :bar))))
  41         (print-level 1))
  42     (elmo-object-save test-elmo-temoporary-file list)
  43     (lunit-assert
  44      (equal list
  45             (elmo-object-load test-elmo-temoporary-file)))))
  46
  47 (luna-define-method test-elmo-save-string-1 ((case test-elmo-util))
  48   )
  49
  50 ;; list functions
  51 (luna-define-method test-elmo-uniq-list-1 ((case test-elmo-util))
  52   (lunit-assert
  53    (eq nil (elmo-uniq-list nil)))
  54   (lunit-assert
  55    (equal '(1) (elmo-uniq-list '(1))))
  56   (lunit-assert
  57    (equal '(1) (elmo-uniq-list '(1 1))))
  58   (lunit-assert
  59    (equal '(1) (elmo-uniq-list '(1 1 1)))))
  60
  61 (luna-define-method test-elmo-uniq-list-2 ((case test-elmo-util))
  62   (lunit-assert
  63    (equal '(1 2 3 4 5 6 nil)
  64           (elmo-uniq-list '(1 2 3 4 1 5 6 nil nil 1 1 2))))
  65   (lunit-assert
  66    (equal '("foo") (elmo-uniq-list '("foo" "foo")))))
  67
  68 (luna-define-method test-elmo-uniq-list-3 ((case test-elmo-util))
  69   "Check using DELETE-FUNCTION"
  70   (lunit-assert
  71    (equal '("foo" "foo") (elmo-uniq-list '("foo" "foo") #'delq)))
  72   (lunit-assert
  73    (equal '(:foo) (elmo-uniq-list '(:foo :foo) #'delq))))
  74
  75 (luna-define-method test-elmo-list-insert-1 ((case test-elmo-util))
  76   (lunit-assert
  77    (equal '(1 2 3 4 5)
  78           (elmo-list-insert '(1 2 3 5) 4 3)))
  79   (lunit-assert
  80    (equal '(1 2 3 5 9)
  81           (elmo-list-insert '(1 2 3 5) 9 :notfound)))
  82 ;;; memq vs. member
  83 ;;;   (equal '(1 2 "3" 5 4)
  84 ;;;       (elmo-list-insert '(1 2 "3" 5) 4 "3"))
  85    )
  86
  87 (luna-define-method test-elmo-list-insert-2 ((case test-elmo-util))
  88   "Check not copied"
  89   (let* ((list1 '(1 2 3 4 5))
  90          (list2 list1))
  91     (elmo-list-insert list1 4 3)
  92     (lunit-assert
  93      (eq list1 list2))))
  94 ;;; memq vs. member
  95 ;;;   (equal '(1 2 "3" 5 4)
  96 ;;;       (elmo-list-insert '(1 2 "3" 5) 4 "3"))
  97
  98 (defun test-elmo-same-list-p (list1 list2)
  99   (let ((clist1 (copy-sequence list1))
 100         (clist2 (copy-sequence list2)))
 101     (while list2
 102       (setq clist1 (delq (car list2) clist1))
 103       (setq list2 (cdr list2)))
 104     (while list1
 105       (setq clist2 (delq (car list1) clist2))
 106       (setq list1 (cdr list1)))
 107     (equal (list clist1 clist2) '(nil nil))))
 108
 109 (defun test-elmo-same-diff-p (diff1 diff2)
 110   (and (test-elmo-same-list-p (car diff1)
 111                               (car diff2))
 112        (test-elmo-same-list-p (nth 1 diff1)
 113                               (nth 1 diff2))))
 114
 115 (luna-define-method test-elmo-list-diff ((case test-elmo-util))
 116   (let ((list1 '(1 2 3))
 117         (list2 '(1 2 3 4))
 118         (list3 '(1 2 4))
 119         (list4 '(4 5 6))
 120         (list5 '(3 4 5 6)))
 121     (lunit-assert
 122      (test-elmo-same-diff-p '(nil nil)
 123                             (elmo-list-diff nil nil)))
 124     (lunit-assert
 125      (test-elmo-same-diff-p '(nil (1 2 3))
 126                             (elmo-list-diff nil list1)))
 127     (lunit-assert
 128      (test-elmo-same-diff-p '((1 2 3) nil)
 129                             (elmo-list-diff list1 nil)))
 130     (lunit-assert
 131      (test-elmo-same-diff-p '(nil nil)
 132                             (elmo-list-diff list1 list1)))
 133     (lunit-assert
 134      (test-elmo-same-diff-p '(nil (4))
 135                             (elmo-list-diff list1 list2)))
 136     (lunit-assert
 137      (test-elmo-same-diff-p '((3) (4))
 138                             (elmo-list-diff list1 list3)))
 139     (lunit-assert
 140      (test-elmo-same-diff-p '((1 2 3) (4 5 6))
 141                             (elmo-list-diff list1 list4)))
 142     (lunit-assert
 143      (test-elmo-same-diff-p '((1 2) (5 6))
 144                             (elmo-list-diff list3 list4)))
 145     (lunit-assert
 146      (test-elmo-same-diff-p '((1 2) (3 5 6))
 147                             (elmo-list-diff list3 list5)))))
 148
 149 (luna-define-method test-elmo-delete-char-1 ((case test-elmo-util))
 150   (lunit-assert
 151    (string= "f" (elmo-delete-char ?o "foo")))
 152   (lunit-assert
 153    (string= "f\nf" (elmo-delete-char ?o "foo\nfoo")))
 154   (lunit-assert
 155    (string= "" (elmo-delete-char ?o  "oo")))
 156   (lunit-assert
 157    (string= "" (elmo-delete-char ?o  ""))))
 158
 159 (luna-define-method test-elmo-concat-path-1 ((case test-elmo-util))
 160   (lunit-assert
 161    (string=
 162     "/home/foo"
 163     (elmo-concat-path "/home" "foo")))
 164   (lunit-assert
 165    (string=
 166     (elmo-concat-path "/home/" "foo")
 167     (elmo-concat-path "/home//" "foo"))))
 168
 169
 170 (luna-define-method test-elmo-remove-passwd-1 ((case test-elmo-util))
 171   "Check shred password."
 172   (let* ((password "cGFzc3dk")
 173          (elmo-passwd-alist (list (cons "key" password))))
 174     (elmo-remove-passwd "key")
 175     (lunit-assert
 176      (string= "\0\0\0\0\0\0\0\0" password))))
 177
 178 (luna-define-method test-elmo-remove-passwd-2 ((case test-elmo-util))
 179   "Check remove target pair only.  Not rassoc."
 180   (let ((password "cGFzc3dk")
 181         (elmo-passwd-alist '(("foo" . "key")
 182                              ("key" . "ok")
 183                              ("bar" . "baz"))))
 184     (elmo-remove-passwd "key")
 185     (lunit-assert
 186      (equal '(("foo" . "key")
 187               ("bar" . "baz"))
 188             elmo-passwd-alist))))
 189
 190 (luna-define-method test-elmo-remove-passwd-3 ((case test-elmo-util))
 191   "Multiple same key."
 192   (let ((password "cGFzc3dk")
 193         (elmo-passwd-alist '(("foo" . "key")
 194                              ("key" . "ok")
 195                              ("key" . "ok2")
 196                              ("bar" . "baz"))))
 197     (elmo-remove-passwd "key")
 198     (lunit-assert
 199      (equal '(("foo" . "key")
 200               ("bar" . "baz"))
 201             elmo-passwd-alist))))
 202
 203 (luna-define-method test-elmo-passwd-alist-clear-1 ((case test-elmo-util))
 204   "Check shred ALL password."
 205   (let* ((password1 "cGFzc3dk")
 206          (password2 (copy-sequence password1))
 207          (elmo-passwd-alist (list (cons "key1" password1)
 208                                   (cons "key2" password2))))
 209     (elmo-passwd-alist-clear)
 210     (lunit-assert
 211      (string= "\0\0\0\0\0\0\0\0" password1))
 212     (lunit-assert
 213      (string= "\0\0\0\0\0\0\0\0" password2))))
 214
 215 (luna-define-method test-elmo-address-quote-specials-1 ((case test-elmo-util))
 216   ""
 217   (lunit-assert
 218    (string= "\"dot.atom.text\""
 219             (elmo-address-quote-specials "dot.atom.text")))
 220   (lunit-assert
 221    (string= "\"...\""
 222             (elmo-address-quote-specials "..."))))
 223
 224 (luna-define-method test-elmo-address-quote-specials-2 ((case test-elmo-util))
 225   ""
 226   (lunit-assert
 227    (string=
 228     "atext!#$%&'*+-/=?^_`{|}~"
 229     (elmo-address-quote-specials "atext!#$%&'*+-/=?^_`{|}~"))))
 230
 231 (luna-define-method test-elmo-elmo-flatten-1 ((case test-elmo-util))
 232   ""
 233   (lunit-assert
 234    (equal
 235     '(1 2 3 4 5)
 236     (elmo-flatten '(1 2 (3 4 5))))))
 237
 238 (luna-define-method test-elmo-number-set-member-1 ((case test-elmo-util))
 239   "Check edge."
 240   (lunit-assert
 241    (equal '((1 . 99))
 242           (elmo-number-set-member 1 '((1 . 99)))))
 243   (lunit-assert
 244    (equal '((1 . 99))
 245           (elmo-number-set-member 99 '((1 . 99))))))
 246
 247 (luna-define-method test-elmo-number-set-member-2 ((case test-elmo-util))
 248   "Check edge."
 249   (lunit-assert
 250    (null (elmo-number-set-member 0 '((1 . 99)))))
 251   (lunit-assert
 252    (null (elmo-number-set-member 100 '((1 . 99))))))
 253
 254 (luna-define-method test-elmo-number-set-append-list-1 ((case test-elmo-util))
 255   "Simple testcase."
 256   (lunit-assert
 257    (equal '((1 . 100))
 258           (elmo-number-set-append-list '((1 . 99)) '(100)))))
 259
 260 (luna-define-method test-elmo-number-set-append-1 ((case test-elmo-util))
 261   "Simple testcase."
 262   (lunit-assert
 263    (equal '((1 . 100))
 264           (elmo-number-set-append '((1 . 99)) 100))))
 265
 266 (luna-define-method test-elmo-number-set-delete-1 ((case test-elmo-util))
 267   "Check edge."
 268   (lunit-assert
 269    (equal '(2 3)
 270           (elmo-number-set-delete '(1 2 3) 1))))
 271
 272 (luna-define-method test-elmo-number-set-delete-2 ((case test-elmo-util))
 273   "Normal case."
 274   (lunit-assert
 275    (equal '(1 3)
 276           (elmo-number-set-delete '(1 2 3) 2))))
 277
 278 (luna-define-method test-elmo-number-set-delete-3 ((case test-elmo-util))
 279   "Check edge."
 280   (lunit-assert
 281    (equal '(1 2)
 282           (elmo-number-set-delete '(1 2 3) 3))))
 283
 284 (luna-define-method test-elmo-number-set-delete-4 ((case test-elmo-util))
 285   "Check edge."
 286   (lunit-assert
 287    (equal '((2 . 100))
 288           (elmo-number-set-delete '((1 . 100)) 1))))
 289
 290 (luna-define-method test-elmo-number-set-delete-5 ((case test-elmo-util))
 291   "Check edge."
 292   (lunit-assert
 293    (equal '(1 (3 . 100))
 294           (elmo-number-set-delete '((1 . 100)) 2))))
 295
 296 (luna-define-method test-elmo-number-set-delete-6 ((case test-elmo-util))
 297   "Normal case."
 298   (lunit-assert
 299    (equal '((1 . 49) (51 . 100))
 300           (elmo-number-set-delete '((1 . 100)) 50))))
 301
 302 (luna-define-method test-elmo-number-set-delete-7 ((case test-elmo-util))
 303   "Check edge."
 304   (lunit-assert
 305    (equal '((1 . 98) 100)
 306           (elmo-number-set-delete '((1 . 100)) 99))))
 307
 308 (luna-define-method test-elmo-number-set-delete-8 ((case test-elmo-util))
 309   "Check edge."
 310   (lunit-assert
 311    (equal '((1 . 99))
 312           (elmo-number-set-delete '((1 . 100)) 100))))
 313
 314 (luna-define-method test-elmo-number-set-delete-list-1 ((case test-elmo-util))
 315   "Simple testcase."
 316   (lunit-assert
 317    (equal '((1 . 99))
 318           (elmo-number-set-delete-list '((1 . 100)) '(100)))))
 319
 320 (luna-define-method test-elmo-number-set-to-number-list-1 ((case test-elmo-util))
 321   "Simple testcase."
 322   (lunit-assert
 323    (equal '(1 2 3 4 5 6 7 8 9)
 324           (elmo-number-set-to-number-list '((1 . 9)))))
 325   (lunit-assert
 326    (equal '(1)
 327           (elmo-number-set-to-number-list '(1)))))
 328
 329 (luna-define-method test-elmo-delete-cr-1 ((case test-elmo-util))
 330   (lunit-assert (string= "" (elmo-delete-cr "")))
 331   (lunit-assert (string= "\n" (elmo-delete-cr "\r\n")))
 332   (lunit-assert (string= "\n\n" (elmo-delete-cr "\r\n\n")))
 333   (lunit-assert (string= "\n\n" (elmo-delete-cr "\r\n\r\n"))))