(define test-1
  (lambda ()
    (equal?
      6
      (eval '((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
      (eval '(let* ((x 0)
                     (f (lambda (y) (+ 1 x)))
                     (x 2))
                (f 0))))))

(define test-3
  (lambda ()
    (equal?
      1
      (eval '(+ 1 (abort 1))))))

(define test-4
  (lambda ()
    (equal?
      2
      (eval '(+ 1 (let/cc x 1))))))

(define test-5
  (lambda ()
    (equal?
      'right
      (eval '(let ((pi (lambda (l)
                         (let/cc k
                           (letrec ((pi (lambda (l)
                                          (if (pair? l)
                                              (if (zero? (car l))
                                                  (k 'right)
                                                  (* (car l) (pi (cdr l))))
                                              1))))
                             (pi l))))))
               (pi (cons 1 (cons 2 (cons 0 (cons 4 ()))))))))))

(define test-6
  (lambda ()
    (equal?
      1
      (eval '(let ((x 1))
               (begin
                 (let/cc k
                   (dynamic-let ((x 2)) (k #f)))
                 x))))))

(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 "~%") (flush-output)))

;(testit)
;(exit)