(define test-1
  (lambda ()
    (equal?
      6
      (eval1 '((lambda (x) (+ x x))
               (let ((y 1) (z 2))
                 (if (number? y) (+ y z) 9)))))))

(define test-2 ; check for lexical scoping
  (lambda ()
    (equal?
      1
      (eval1 '(let* ((x 0)
                     (f (lambda (y) (+ 1 x)))
                     (x 2))
                (f 0))))))

(define test-3
  (lambda ()
    (equal?
      6
      (eval1 '((lambda (x) (+ x x))
               (let ((y 1) (z 2))
                 (let* ((y (- y 1))
                        (y (+ y 1)))
                   (if (number? y) (+ y z) 9))))))))
      
(define test-4
  (lambda ()
    (equal?
      6
      (eval2 '((lambda (x) (+ x x))
               (let ((y 1) (z 2))
                 (if (number? y) (+ y z) 9)))))))

(define test-5
  (lambda ()
    (equal?
      6
      (eval2 '((lambda (x) (+ x x))
               (let ((y 1) (z 2))
                 (let* ((y (- y 1))
                        (y (+ y 1)))
                   (if (number? y) (+ y z) 9))))))))

(define test-6
  (lambda ()
    (equal?
      120
      (eval3 '(letrec ((fact (lambda (n)
                               (if (= 0 n)
                                   1
                                   (* n (fact (- n 1)))))))
                (fact 5))))))

(define test-7
  (lambda ()
    (equal?
      #t
      (eval3 '(letrec ((oddl (lambda (l)
                               (if (not (pair? l))
                                   #f
                                   (evenl (cdr l)))))
                       (evenl (lambda (l)
                                (if (not (pair? l))
                                    #t
                                    (oddl (cdr l))))))
                (oddl (cons 1 (cons 'a (cons 3 ())))))))))

(define test-8
  (lambda ()
    (equal?
      4
      (eval3 '(let* ((x 1)
                     (y (set! x (+ x 3))))
                x)))))

(define test-9
  (lambda ()
    (equal? #t
      (eval3 '(let* ((x 1)
                     (f (lambda () x))
                     (p (cons x
                              (cons (dynamic-let ((x 2)) (f))
                                    x))))
                (if (= 1 (car p))
                    (if (= 2 (car (cdr p)))
                        (if (= 1 (cdr (cdr p)))
                            #t
                            #f)
                        #f)
                    #f))))))

(define testit
  (lambda ()
    (printf "1: ~a " (test-1)) (flush-output)
    (printf "2: ~a " (test-2)) (flush-output)
    (printf "3: ~a " (test-3)) (flush-output)
    (printf "4: ~a " (test-4)) (flush-output)
    (printf "5: ~a " (test-5)) (flush-output)
    (printf "6: ~a " (test-6)) (flush-output)
    (printf "7: ~a " (test-7)) (flush-output)
    (printf "8: ~a " (test-8)) (flush-output)
    (printf "9: ~a " (test-9)) (flush-output)
    (printf "~%") (flush-output)))

;(testit)
;(exit)