cherry-pick changes in tests from kanaka#592

impls/tests/step3_env.mal

@@ -85,3 +85,23 @@ y
 ;; Check that last assignment takes priority
 (let* (x 2 x 3) x)
 ;=>3
+
+;; Check DEBUG-EVAL
+(let* (DEBUG-EVAL false) (- 3 1))
+;=>2
+(let* (DEBUG-EVAL nil) (- 3 1))
+;=>2
+;;; Some implementations avoid a recursive EVAL when the first element
+;;; is a symbol or when map(EVAL, list) encounters a number.
+(let* (a 3 b 2 DEBUG-EVAL true) (- a b))
+;/EVAL: \(- a b\).*\n1
+;; Check the readably pretty-printing option
+(let* (DEBUG-EVAL 1) "a")
+;/EVAL: "a".*\n"a"
+;; Usually false values
+(let* (a 3 DEBUG-EVAL ()) a)
+;/EVAL: a.*\n3
+(let* (a 3 DEBUG-EVAL 0) a)
+;/EVAL: a.*\n3
+(let* (a 3 DEBUG-EVAL "") a)
+;/EVAL: a.*\n3

impls/tests/step7_quote.mal

@@ -76,8 +76,6 @@ b
 ;=>(1 () 2)
 (quasiquote (()))
 ;=>(())
-;; (quasiquote (f () g (h) i (j k) l))
-;; =>(f () g (h) i (j k) l)
 
 ;; Testing unquote
 (quasiquote (unquote 7))
@@ -278,72 +276,21 @@ a
 `[splice-unquote 0]
 ;=>[splice-unquote 0]
 
-;; Debugging quasiquote
-(quasiquoteexpand nil)
-;=>nil
-(quasiquoteexpand 7)
-;=>7
-(quasiquoteexpand a)
-;=>(quote a)
-(quasiquoteexpand {"a" b})
-;=>(quote {"a" b})
-(quasiquoteexpand ())
-;=>()
-(quasiquoteexpand (1 2 3))
-;=>(cons 1 (cons 2 (cons 3 ())))
-(quasiquoteexpand (a))
-;=>(cons (quote a) ())
-(quasiquoteexpand (1 2 (3 4)))
-;=>(cons 1 (cons 2 (cons (cons 3 (cons 4 ())) ())))
-(quasiquoteexpand (nil))
-;=>(cons nil ())
-(quasiquoteexpand (1 ()))
-;=>(cons 1 (cons () ()))
-(quasiquoteexpand (() 1))
-;=>(cons () (cons 1 ()))
-(quasiquoteexpand (1 () 2))
-;=>(cons 1 (cons () (cons 2 ())))
-(quasiquoteexpand (()))
-;=>(cons () ())
-(quasiquoteexpand (f () g (h) i (j k) l))
-;=>(cons (quote f) (cons () (cons (quote g) (cons (cons (quote h) ()) (cons (quote i) (cons (cons (quote j) (cons (quote k) ())) (cons (quote l) ())))))))
-(quasiquoteexpand (unquote 7))
-;=>7
-(quasiquoteexpand a)
-;=>(quote a)
-(quasiquoteexpand (unquote a))
-;=>a
-(quasiquoteexpand (1 a 3))
-;=>(cons 1 (cons (quote a) (cons 3 ())))
-(quasiquoteexpand (1 (unquote a) 3))
-;=>(cons 1 (cons a (cons 3 ())))
-(quasiquoteexpand (1 b 3))
-;=>(cons 1 (cons (quote b) (cons 3 ())))
-(quasiquoteexpand (1 (unquote b) 3))
-;=>(cons 1 (cons b (cons 3 ())))
-(quasiquoteexpand ((unquote 1) (unquote 2)))
-;=>(cons 1 (cons 2 ()))
-(quasiquoteexpand (a (splice-unquote (b c)) d))
-;=>(cons (quote a) (concat (b c) (cons (quote d) ())))
-(quasiquoteexpand (1 c 3))
-;=>(cons 1 (cons (quote c) (cons 3 ())))
-(quasiquoteexpand (1 (splice-unquote c) 3))
-;=>(cons 1 (concat c (cons 3 ())))
-(quasiquoteexpand (1 (splice-unquote c)))
-;=>(cons 1 (concat c ()))
-(quasiquoteexpand ((splice-unquote c) 2))
-;=>(concat c (cons 2 ()))
-(quasiquoteexpand ((splice-unquote c) (splice-unquote c)))
-;=>(concat c (concat c ()))
-(quasiquoteexpand [])
-;=>(vec ())
-(quasiquoteexpand [[]])
-;=>(vec (cons (vec ()) ()))
-(quasiquoteexpand [()])
-;=>(vec (cons () ()))
-(quasiquoteexpand ([]))
-;=>(cons (vec ()) ())
-(quasiquoteexpand [1 a 3])
-;=>(vec (cons 1 (cons (quote a) (cons 3 ()))))
-(quasiquoteexpand [a [] b [c] d [e f] g])
-;=>(vec (cons (quote a) (cons (vec ()) (cons (quote b) (cons (vec (cons (quote c) ())) (cons (quote d) (cons (vec (cons (quote e) (cons (quote f) ()))) (cons (quote g) ()))))))))
+(let* (DEBUG-EVAL true) `nil)
+;/EVAL: nil.*\nnil
+(let* (DEBUG-EVAL true) `7)
+;/EVAL: 7.*\n7
+(let* (DEBUG-EVAL true) `a)
+;/EVAL: \(quote a\).*\na
+(let* (DEBUG-EVAL true) `{"a" b})
+;/EVAL: \(quote \{"a" b\}\).*\n\{"a" b\}
+(let* (DEBUG-EVAL true) `())
+;/EVAL: \(\).*\n\(\)
+(let* (DEBUG-EVAL true) `(a 2))
+;/EVAL: \(cons \(quote a\) \(cons 2 \(\)\)\).*\n\(a 2\)
+(let* (DEBUG-EVAL true) `(~a 3))
+;/EVAL: \(cons a \(cons 3 \(\)\)\).*\n\(8 3\)
+(let* (DEBUG-EVAL true) `(1 ~@c 3))
+;/EVAL: \(cons 1 \(concat c \(cons 3 \(\)\)\)\).*\n\(1 1 "b" "d" 3\)
+(let* (DEBUG-EVAL true) `[])
+;/EVAL: \(vec \(\)\).*\n\[\]

impls/tests/step8_macros.mal

@@ -18,20 +18,8 @@
 (unless2 true 7 8)
 ;=>8
 
-;; Testing macroexpand
-(macroexpand (one))
-;=>1
-(macroexpand (unless PRED A B))
-;=>(if PRED B A)
-(macroexpand (unless2 PRED A B))
-;=>(if (not PRED) A B)
-(macroexpand (unless2 2 3 4))
-;=>(if (not 2) 3 4)
-
 ;; Testing evaluation of macro result
 (defmacro! identity (fn* (x) x))
-(let* (a 123) (macroexpand (identity a)))
-;=>a
 (let* (a 123) (identity a))
 ;=>123
 
@@ -84,18 +72,12 @@ x
 
 ;; Testing cond macro
 
-(macroexpand (cond))
-;=>nil
 (cond)
 ;=>nil
-(macroexpand (cond X Y))
-;=>(if X Y (cond))
 (cond true 7)
 ;=>7
 (cond false 7)
 ;=>nil
-(macroexpand (cond X Y Z T))
-;=>(if X Y (cond Z T))
 (cond true 7 true 8)
 ;=>7
 (cond false 7 true 8)
@@ -163,3 +145,10 @@ x
 ;=>2
 (let* (x 3) (a))
 ;=>2
+
+(let* (DEBUG-EVAL true) (unless x foo (- 4 3)))
+;/EVAL: \(if x \(- 4 3\) foo\).*\n1
+(let* (DEBUG-EVAL true) (unless2 x foo (- 4 3)))
+;/EVAL: \(if \(not x\) foo \(- 4 3\)\).*\n1
+(let* (DEBUG-EVAL true) (cond x (- 4 3) foo bar))
+;/EVAL: \(if x \(- 4 3\) \(cond foo bar\)\).*\n1