;; the basic unit-test syntax, from http://c2.com/cgi/wiki?LispUnit
;;(define-syntax unit-test/basic
;;  (syntax-rules (=>)
;;    ((unit-test expr) ; assume we want #t if no expected value is given
;;     (unit-test expr => #t))
;;    ((unit-test expr => result)
;;     (unless (equal? expr result)
;;       (error (format #f "Unit test failed: ~A => ~A" 'expr expr))))))

(define-syntax unit-test
  (syntax-rules (=>)
    ((unit-test expr)
     (unit-test expr => #t))
    ((unit-test expr => result)
     (unless (equal? expr result)
       (format #t "failed: ~a => ~a, expected ~a\n"
               'expr expr result)))))

;; (define (test-suite . tests)
;;   ...)

;; TODO
;; make unit-test register the test with the test-runner
;; organise tests into a tree: test suites
;;(define-testsuite suite-name
;;  (expression :optional expected-result description)
;;  ...)
;;(unit-tests
;;  (test)
;;  ...)

(define (unit-test-tests)
  (define (my-map fn ls)
    (if (null? ls)
        '()
        (cons (fn (car ls))
              (my-map fn (cdr ls)))))

  (define (reduce base f ls)
    (cond ((null? ls) base)
          (else (reduce (f (car ls) base) f (cdr ls)))))

  ;; sort : (listof number) -> (listof number)
  (define (sort. l)
    (define (insert an alon)
      (cond ((null? alon) (list an))
            (else (cond ((< an (car alon)) (cons an alon))
                        (else (cons (car alon) (insert an (cdr alon))))))))
    (reduce '() insert l))

  (unit-test (eq? 'a 'a))
  ;; fails:
  (unit-test (+ 2 3) => 6)

  (unit-test (my-map length '((a) (b c) (d e f))) => '(1 2 3))
  (unit-test (my-map (lambda (x) (impossible)) '()) => '())
  (unit-test (my-map even? '(1 2 3 4)) => '(#f #t #f #t))
  ;; fails:
  (unit-test (my-map even? '(1 2 3 4)) => '(#t #t #t #t))

  (unit-test (reduce 0 + '()) => 0)
  (unit-test (reduce 0 + '(1)) => 1)
  (unit-test (reduce 0 + '(1 2 3)) => 6)
  (unit-test (reduce 1 * '(1 2 3 4 5)) => 120)
  ;; fails:
  (unit-test (reduce 1 + '(1 2 3)) => 7)

  (unit-test (sort. '()) => '())
  (unit-test (sort. '(9 7 5 3 1 8 6 4 2)) => '(1 2 3 4 5 6 7 8 9))
  (unit-test (sort. '(0 0 0)) => '(0 0 0))
  ;; fails:
  (unit-test (sort. '(0 0 0)) => '(0 0 1)))