(import simple-tests)

;;; old interface

(define-test (bar n)
  (positive? n)
  (even? n))

(define-test (foo x y)
  (< x y)
  "COMMENT"
  (bar 4)
  (odd? 3)
  (positive? 3))

(define-test (++)
  (= (+ 1 2) 3)
  (= (+ 1 2 3) 6))

(define-test (**)
  (= (* 1 2) 2)
  (= (* 1 2 3) 6))

(define-test (arithmetic)
  (++)
  (**))

(define-test (baz)
  (and? #t #t #t)
  (and?)
  (not (and? #t #f #t)))


;(compound-test (simple-tests)
;  (baz)
;  (arithmetic?)
;  (foo 1 2)
;  )

;;; new interface

(newline)
(print "check")
(print "=====")
(check ((lst '(0 1 2 3)))
  lst
  '(0 1 2 3)
  (car lst)
  0
  (cadr lst)
  1
  (cddr lst)
  '(2 3)
  )

;;; define-checks is an alias to do-checks
(do-checks (bar? verbose? n 5)
  (positive? n) #t
  (even? n) #f)

(define-checks (+? verbose?)
  (+ 1 2) 3
  (+ 1 2 3) 6)

(define-checks (*? verbose?)
  (* 1 2) 2
  (* 1 2 3) 6)

(define-checks (arithmetic? verbose?)
  (+? #f) #t
  (*? #f) #t)

(do-checks (baz? verbose?)
  (and? #t #t #t) #t
  (and?) #t
  (and? #t #f #t) #f)

(define-checks (qux? verbose?)
  ((== "x") "y") #f
  ((== "x") "x") #t
  ((== baz?) baz?) #t
  ((== baz?) bar) #f
  ((== '()) '()) #t
  ((== 'x) 'y) #f
  ((== 'x) 'x) #t
  ((== #(0 1 2)) #(0 1 2)) #t
  ((== #(0 1 2)) '(0 1 2)) #f
  )

(define counter
  (let ((n 0))
    (lambda ()
      (set! n (add1 n))
      n)))

(define-checks (counter? verbose?)
  (counter) 1
  (counter) 2
  (counter) 3
  (counter) 4
  )


(check-all SIMPLE (bar?) (*?) (+?) (arithmetic?) (baz?) (qux?)
           (counter?))