Implemented unless, when and dotimes using built-in macros.

[bpt/guile.git] / test-suite / tests / elisp-compiler.test

diff --git a/test-suite/tests/elisp-compiler.test b/test-suite/tests/elisp-compiler.test
index fdb6771..d36f47c 100644 (file)
--- a/test-suite/tests/elisp-compiler.test
+++ b/test-suite/tests/elisp-compiler.test
@@ -56,12 +56,24 @@
 
   (pass-if-equal "succeeding if" 1
     (if t 1 2))
-  (pass-if-equal "failing if" 3
-    (if nil
-      1
-      (setq a 2)
-      (setq a (1+ a))
-      a))
+  (pass-if "failing if"
+    (and (= (if nil
+              1
+              (setq a 2) (setq a (1+ a)) a)
+            3)
+         (equal (if nil 1) nil)))
+
+  (pass-if-equal "failing when" nil-value
+    (when nil 1 2 3))
+  (pass-if-equal "succeeding when" 42
+    (progn (setq a 0)
+           (when t (setq a 42) a)))
+
+  (pass-if-equal "failing unless" nil-value
+    (unless t 1 2 3))
+  (pass-if-equal "succeeding unless" 42
+    (progn (setq a 0)
+           (unless nil (setq a 42) a)))
 
   (pass-if-equal "empty cond" nil-value
     (cond))
@@ -101,7 +113,16 @@
            (while (<= i 5)
              (setq prod (* i prod))
              (setq i (1+ i)))
-           prod)))
+           prod))
+
+  (pass-if "dotimes"
+    (progn (setq a 0)
+           (setq count 100)
+           (setq b (dotimes (i count)
+                     (setq j (1+ i))
+                     (setq a (+ a j))))
+           (setq c (dotimes (i 10 42) nil))
+           (and (= a 5050) (equal b nil) (= c 42)))))
 
 
 ; Test handling of variables.
@@ -112,10 +133,11 @@
   ; TODO: Check for variable-void error
 
   (pass-if-equal "setq and reference" 6
-    (progn (setq a 1
-                 b 2
-                 c 3)
-           (+ a b c))))
+    (progn (setq a 1 b 2 c 3)
+           (+ a b c)))
+
+  (pass-if-equal "setq value" 2
+    (progn (setq a 1 b 2))))
 
 (with-test-prefix/compile "Let and Let*"
 
@@ -211,9 +233,67 @@
                 (zerop a)))))
 
 
+; Quoting and Backquotation.
+; ==========================
+
+(with-test-prefix/compile "Quotation"
+
+  (pass-if "quote"
+    (and (equal '42 42) (equal '"abc" "abc")
+         (equal '(1 2 (3 (4) x)) '(1 2 (3 (4) x)))
+         (not (equal '(1 2 (3 4 (x))) '(1 2 3 4 x)))
+         (equal '(1 2 . 3) '(1 2 . 3))))
+
+  (pass-if "simple backquote"
+    (and (equal (\` 42) 42)
+         (equal (\` (1 (a))) '(1 (a)))
+         (equal (\` (1 . 2)) '(1 . 2))))
+  (pass-if "unquote"
+    (progn (setq a 42 l '(18 12))
+           (and (equal (\` (\, a)) 42)
+                (equal (\` (1 a ((\, l)) . (\, a))) '(1 a ((18 12)) . 42)))))
+  (pass-if "unquote splicing"
+    (progn (setq l '(18 12) empty '())
+           (and (equal (\` (\,@ l)) '(18 12))
+                (equal (\` (l 2 (3 (\,@ l)) ((\,@ l)) (\,@ l)))
+                       '(l 2 (3 18 12) (18 12) 18 12))
+                (equal (\` (1 2 (\,@ empty) 3)) '(1 2 3))))))
+      
+
+
+; Macros.
+; =======
+
+(with-test-prefix/compile "Macros"
+
+  (pass-if-equal "defmacro value" 'magic-number
+    (defmacro magic-number () 42))
+
+  (pass-if-equal "macro expansion" 1
+    (progn (defmacro take-first (a b) a)
+           (take-first 1 (/ 1 0)))))
+
+
 ; Test the built-ins.
 ; ===================
 
+(with-test-prefix/compile "Equivalence Predicates"
+
+  (pass-if "equal"
+    (and (equal 2 2) (not (equal 1 2))
+         (equal "abc" "abc") (not (equal "abc" "ABC"))
+         (equal 'abc 'abc) (not (equal 'abc 'def))
+         (equal '(1 2 (3 4) 5) '(1 2 (3 4) 5))
+         (not (equal '(1 2 3 4 5) '(1 2 (3 4) 5)))))
+
+  (pass-if "eq"
+    (progn (setq some-list '(1 2))
+           (setq some-string "abc")
+           (and (eq 2 2) (not (eq 1 2))
+                (eq 'abc 'abc) (not (eq 'abc 'def))
+                (eq some-string some-string) (not (eq some-string "abc"))
+                (eq some-list some-list) (not (eq some-list '(1 2)))))))
+
 (with-test-prefix/compile "Number Built-Ins"
 
   (pass-if "floatp"