Mercurial > hg > xemacs-beta

diff tests/automated/symbol-tests.el @ 5136:0f66906b6e37

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Undo Assert-equal, Assert=, etc.; make `Assert' handle this automatically -------------------- ChangeLog entries follow: -------------------- lisp/ChangeLog addition: 2010-03-12 Ben Wing <ben@xemacs.org> * test-harness.el (test-harness-from-buffer): Undo change of e.g. (Assert (equalp ...)) to (Assert-equalp ...). Get rid of `Assert-equalp' and friends, `Assert-test', and `Assert-test-not'. Instead, make `Assert' smart enough to do the equivalent functionality when an expression like (Assert (equalp ...)) is seen. tests/ChangeLog addition: 2010-03-12 Ben Wing <ben@xemacs.org> * automated/base64-tests.el (bt-base64-encode-string): * automated/base64-tests.el (bt-base64-decode-string): * automated/base64-tests.el (for): * automated/byte-compiler-tests.el: * automated/byte-compiler-tests.el (before-and-after-compile-equal): * automated/case-tests.el (downcase-string): * automated/case-tests.el (uni-mappings): * automated/ccl-tests.el (ccl-test-normal-expr): * automated/ccl-tests.el (ccl-test-map-instructions): * automated/ccl-tests.el (ccl-test-suites): * automated/database-tests.el (delete-database-files): * automated/extent-tests.el (let): * automated/extent-tests.el (insert): * automated/extent-tests.el (props): * automated/file-tests.el: * automated/file-tests.el (for): * automated/hash-table-tests.el (test): * automated/hash-table-tests.el (for): * automated/hash-table-tests.el (ht): * automated/hash-table-tests.el (iterations): * automated/hash-table-tests.el (h1): * automated/hash-table-tests.el (equal): * automated/hash-table-tests.el (=): * automated/lisp-tests.el: * automated/lisp-tests.el (eq): * automated/lisp-tests.el (test-setq): * automated/lisp-tests.el (my-vector): * automated/lisp-tests.el (x): * automated/lisp-tests.el (equal): * automated/lisp-tests.el (y): * automated/lisp-tests.el (featurep): * automated/lisp-tests.el (=): * automated/lisp-tests.el (six): * automated/lisp-tests.el (three): * automated/lisp-tests.el (one): * automated/lisp-tests.el (two): * automated/lisp-tests.el (five): * automated/lisp-tests.el (test1): * automated/lisp-tests.el (division-test): * automated/lisp-tests.el (for): * automated/lisp-tests.el (check-function-argcounts): * automated/lisp-tests.el (z): * automated/lisp-tests.el (eql): * automated/lisp-tests.el (test-harness-risk-infloops): * automated/lisp-tests.el (erase-buffer): * automated/lisp-tests.el (sym): * automated/lisp-tests.el (new-char): * automated/lisp-tests.el (new-load-file-name): * automated/lisp-tests.el (cl-floor): * automated/lisp-tests.el (foo): * automated/md5-tests.el (lambda): * automated/md5-tests.el (large-string): * automated/md5-tests.el (mapcar): * automated/md5-tests.el (insert): * automated/mule-tests.el: * automated/mule-tests.el (test-chars): * automated/mule-tests.el (existing-file-name): * automated/mule-tests.el (featurep): * automated/query-coding-tests.el (featurep): * automated/regexp-tests.el: * automated/regexp-tests.el (insert): * automated/regexp-tests.el (Assert): * automated/regexp-tests.el (=): * automated/regexp-tests.el (featurep): * automated/regexp-tests.el (text): * automated/regexp-tests.el (text1): * automated/regexp-tests.el ("aáa"): * automated/regexp-tests.el (eql): * automated/search-tests.el (insert): * automated/search-tests.el (featurep): * automated/search-tests.el (let): * automated/search-tests.el (boundp): * automated/symbol-tests.el: * automated/symbol-tests.el (name): * automated/symbol-tests.el (check-weak-list-unique): * automated/symbol-tests.el (string): * automated/symbol-tests.el (list): * automated/symbol-tests.el (foo): * automated/symbol-tests.el (eq): * automated/symbol-tests.el (fresh-keyword-name): * automated/symbol-tests.el (print-gensym): * automated/symbol-tests.el (mysym): * automated/syntax-tests.el (test-forward-word): * automated/syntax-tests.el (test-backward-word): * automated/syntax-tests.el (test-syntax-table): * automated/syntax-tests.el (with-syntax-table): * automated/syntax-tests.el (Skip-Test-Unless): * automated/syntax-tests.el (with): * automated/tag-tests.el (testfile): * automated/weak-tests.el (w): * automated/weak-tests.el (p): * automated/weak-tests.el (a): Undo change of e.g. (Assert (equalp ...)) to (Assert-equalp ...). Get rid of `Assert-equalp' and friends, `Assert-test', and `Assert-test-not'. Instead, make `Assert' smart enough to do the equivalent functionality when an expression like (Assert (equalp ...)) is seen.
author Ben Wing <ben@xemacs.org>
date Fri, 12 Mar 2010 18:27:51 -0600
parents 189fb67ca31a
children 308d34e9f07d
line wrap: on
line diff
--- a/tests/automated/symbol-tests.el	Sun Mar 07 06:43:19 2010 -0600
+++ b/tests/automated/symbol-tests.el	Fri Mar 12 18:27:51 2010 -0600
@@ -63,8 +63,8 @@
 	(uninterned (make-symbol name)))
     (Assert (symbolp interned))
     (Assert (symbolp uninterned))
-    (Assert-equal (symbol-name interned) name)
-    (Assert-equal (symbol-name uninterned) name)
+    (Assert (equal (symbol-name interned) name))
+    (Assert (equal (symbol-name uninterned) name))
     (Assert (not (eq interned uninterned)))
     (Assert (not (equal interned uninterned)))))
 
@@ -76,12 +76,12 @@
 	       (Implementation-Incomplete-Expect-Failure
 		(Assert (not (zerop len)))
 		(garbage-collect)
-		(Assert-eq (length (weak-list-list weak-list))
-			    (if (not reversep) 0 len)))
+		(Assert (eq (length (weak-list-list weak-list))
+			    (if (not reversep) 0 len))))
 	     (Assert (not (zerop len)))
 	     (garbage-collect)
-	     (Assert-eq (length (weak-list-list weak-list))
-			 (if (not reversep) 0 len))))))
+	     (Assert (eq (length (weak-list-list weak-list))
+			 (if (not reversep) 0 len)))))))
   (let ((weak-list (make-weak-list))
 	(gc-cons-threshold most-positive-fixnum))
     ;; Symbols created with `make-symbol' and `gensym' should be fresh
@@ -112,7 +112,7 @@
 	string (read (concat "\"" string "\"")))
   (Assert (intern-soft string))
   (Assert (intern-soft symbol))
-  (Assert-eq (intern-soft string) (intern-soft symbol)))
+  (Assert (eq (intern-soft string) (intern-soft symbol))))
 
 (let ((fresh (read (concat "#:" (ts-fresh-symbol-name "foo")))))
   (Assert (not (intern-soft fresh))))
@@ -127,15 +127,15 @@
        (bar3 (nth 5 list)))
   (Assert (symbolp foo))
   (Assert (not (intern-soft foo)))
-  (Assert-equal (symbol-name foo) "foo")
+  (Assert (equal (symbol-name foo) "foo"))
   (Assert (symbolp bar))
   (Assert (not (intern-soft bar)))
-  (Assert-equal (symbol-name bar) "bar")
+  (Assert (equal (symbol-name bar) "bar"))
 
-  (Assert-eq foo foo2)
-  (Assert-eq foo2 foo3)
-  (Assert-eq bar bar2)
-  (Assert-eq bar2 bar3))
+  (Assert (eq foo foo2))
+  (Assert (eq foo2 foo3))
+  (Assert (eq bar bar2))
+  (Assert (eq bar2 bar3)))
 
 ;; Check #N=OBJECT and #N# print syntax.
 (let* ((foo (make-symbol "foo"))
@@ -143,10 +143,10 @@
        (list (list foo foo bar bar foo bar)))
   (let* ((print-gensym nil)
 	 (printed-list (prin1-to-string list)))
-    (Assert-equal printed-list "(foo foo bar bar foo bar)"))
+    (Assert (equal printed-list "(foo foo bar bar foo bar)")))
   (let* ((print-gensym t)
 	 (printed-list (prin1-to-string list)))
-    (Assert-equal printed-list "(#1=#:foo #1# #2=#:bar #2# #1# #2#)")))
+    (Assert (equal printed-list "(#1=#:foo #1# #2=#:bar #2# #1# #2#)"))))
 
 ;;-----------------------------------------------------
 ;; Read-only symbols
@@ -164,18 +164,18 @@
 (let ((foo 0)
       (bar 1))
   (defvaralias 'foo 'bar)
-  (Assert-eq foo bar)
-  (Assert-eq foo 1)
-  (Assert-eq (variable-alias 'foo) 'bar)
+  (Assert (eq foo bar))
+  (Assert (eq foo 1))
+  (Assert (eq (variable-alias 'foo) 'bar))
   (defvaralias 'bar 'foo)
   (Check-Error cyclic-variable-indirection
     (symbol-value 'foo))
   (Check-Error cyclic-variable-indirection
     (symbol-value 'bar))
   (defvaralias 'foo nil)
-  (Assert-eq foo 0)
+  (Assert (eq foo 0))
   (defvaralias 'bar nil)
-  (Assert-eq bar 1))
+  (Assert (eq bar 1)))
 
 ;;-----------------------------------------------------
 ;; Keywords
@@ -187,10 +187,10 @@
 ;; that is interned in the global obarray.
 
 ;; In Elisp, a keyword is interned as any other symbol.
-(Assert-eq (read ":foo") (intern ":foo"))
+(Assert (eq (read ":foo") (intern ":foo")))
 
 ;; A keyword is self-quoting and evaluates to itself.
-(Assert-eq (eval (intern ":foo")) :foo)
+(Assert (eq (eval (intern ":foo")) :foo))
 
 ;; Keywords are recognized as such only if interned in the global
 ;; obarray, and `keywordp' is aware of that.
@@ -208,14 +208,14 @@
 ;; keyword.
 (let* ((fresh-keyword-name (ts-fresh-symbol-name ":foo"))
        (fresh-keyword (intern fresh-keyword-name)))
-  (Assert-eq (symbol-value fresh-keyword) fresh-keyword)
+  (Assert (eq (symbol-value fresh-keyword) fresh-keyword))
   (Assert (keywordp fresh-keyword)))
 
 ;; Likewise, reading a fresh keyword string should produce a regular
 ;; keyword.
 (let* ((fresh-keyword-name (ts-fresh-symbol-name ":foo"))
        (fresh-keyword (read fresh-keyword-name)))
-  (Assert-eq (symbol-value fresh-keyword) fresh-keyword)
+  (Assert (eq (symbol-value fresh-keyword) fresh-keyword))
   (Assert (keywordp fresh-keyword)))
 
 ;;; Assigning to keywords
@@ -236,19 +236,19 @@
 
 ;; But symbols not interned in the global obarray are not real
 ;; keywords (in elisp):
-(Assert-eq (set (intern ":foo" [0]) 5) 5)
+(Assert (eq (set (intern ":foo" [0]) 5) 5))
 
 ;;; Printing keywords
 
 (let ((print-gensym t))
-  (Assert-equal (prin1-to-string :foo)                ":foo")
-  (Assert-equal (prin1-to-string (intern ":foo"))     ":foo")
-  (Assert-equal (prin1-to-string (intern ":foo" [0])) "#::foo"))
+  (Assert (equal (prin1-to-string :foo)                ":foo"))
+  (Assert (equal (prin1-to-string (intern ":foo"))     ":foo"))
+  (Assert (equal (prin1-to-string (intern ":foo" [0])) "#::foo")))
 
 (let ((print-gensym nil))
-  (Assert-equal (prin1-to-string :foo)                ":foo")
-  (Assert-equal (prin1-to-string (intern ":foo"))     ":foo")
-  (Assert-equal (prin1-to-string (intern ":foo" [0])) ":foo"))
+  (Assert (equal (prin1-to-string :foo)                ":foo"))
+  (Assert (equal (prin1-to-string (intern ":foo"))     ":foo"))
+  (Assert (equal (prin1-to-string (intern ":foo" [0])) ":foo")))
 
 ;; #### Add many more tests for printing and reading symbols, as well
 ;; as print-gensym and print-gensym-alist!
@@ -270,17 +270,17 @@
    (lambda (&rest args)
      (throw 'test-tag args)))
   (Assert (not (boundp mysym)))
-  (Assert-equal (catch 'test-tag
+  (Assert (equal (catch 'test-tag
 		   (set mysym 'foo))
-		 `(,mysym (foo) set nil nil))
+		 `(,mysym (foo) set nil nil)))
   (Assert (not (boundp mysym)))
   (dontusethis-set-symbol-value-handler
    mysym
    'set-value
    (lambda (&rest args) (setq save (nth 1 args))))
   (set mysym 'foo)
-  (Assert-equal save '(foo))
-  (Assert-eq (symbol-value mysym) 'foo)
+  (Assert (equal save '(foo)))
+  (Assert (eq (symbol-value mysym) 'foo))
   )
 
 (let ((mysym (make-symbol "test-symbol"))
@@ -290,9 +290,9 @@
    'make-unbound
    (lambda (&rest args)
      (throw 'test-tag args)))
-  (Assert-equal (catch 'test-tag
+  (Assert (equal (catch 'test-tag
 		   (makunbound mysym))
-		 `(,mysym nil makunbound nil nil))
+		 `(,mysym nil makunbound nil nil)))
   (dontusethis-set-symbol-value-handler
    mysym
    'make-unbound
@@ -300,27 +300,27 @@
   (Assert (not (boundp mysym)))
   (set mysym 'bar)
   (Assert (null save))
-  (Assert-eq (symbol-value mysym) 'bar)
+  (Assert (eq (symbol-value mysym) 'bar))
   (makunbound mysym)
   (Assert (not (boundp mysym)))
-  (Assert-eq save 'makunbound)
+  (Assert (eq save 'makunbound))
   )
 
 ;; pathname-coding-system is no more.
 ; (when (featurep 'file-coding)
-;   (Assert-eq pathname-coding-system file-name-coding-system)
+;   (Assert (eq pathname-coding-system file-name-coding-system))
 ;   (let ((val1 file-name-coding-system)
 ; 	(val2 pathname-coding-system))
-;     (Assert-eq val1 val2)
+;     (Assert (eq val1 val2))
 ;     (let ((file-name-coding-system 'no-conversion-dos))
-;       (Assert-eq file-name-coding-system 'no-conversion-dos)
-;       (Assert-eq pathname-coding-system file-name-coding-system))
+;       (Assert (eq file-name-coding-system 'no-conversion-dos))
+;       (Assert (eq pathname-coding-system file-name-coding-system)))
 ;     (let ((pathname-coding-system 'no-conversion-mac))
-;       (Assert-eq file-name-coding-system 'no-conversion-mac)
-;       (Assert-eq pathname-coding-system file-name-coding-system))
-;     (Assert-eq file-name-coding-system pathname-coding-system)
-;     (Assert-eq val1 file-name-coding-system))
-;   (Assert-eq pathname-coding-system file-name-coding-system))
+;       (Assert (eq file-name-coding-system 'no-conversion-mac))
+;       (Assert (eq pathname-coding-system file-name-coding-system)))
+;     (Assert (eq file-name-coding-system pathname-coding-system))
+;     (Assert (eq val1 file-name-coding-system)))
+;   (Assert (eq pathname-coding-system file-name-coding-system)))
 
 
 ;(let ((mysym (make-symbol "test-symbol")))