(require-library cells simple-tests)
(import cells chicken simple-tests)

(define (push st% val)
  (st% (cons val (st%))))
(define (top st%)
  (car (st%)))
(define (pop st%)
  (st% (cdr (st%))))

(define-test (TYPED_CELLS)
  (check
    (define c% (make-cell-of number? positive?))
    ((cell-of? number? positive?) c%)
    (cell-empty? c%)
    (c% 5)
    (not (cell-empty? c%))
    (define d% (make-cell-of boolean?))
    (cell-empty? d%)
    (d% #t)
    (not (cell-empty? d%))
    (d%)
    ((cell-of? boolean?) d%)
    (not ((cell-of? number?) d%))
    (= (c%) 5)
    (not (eqv? (c%) (d%)))
    ((cell-of? number? positive?) c%)
    (= (c%) 5)
    (not ((cell-of? number? zero?) c%))
    ((cell-of? number?) c%)
    ((cell-of?) c%)
    (cell-prune! c%)
    (cell-empty? c%)
    (not (condition-case (c% -5)
           ((exn) #f)))
    (define e% (make-cell-of number?))
    (e% -5)
    (= (e%) -5)
    (not ((cell-of? number? positive?) e%))
    ((cell-of? number?) e%)
    ))

(define-test (CELLS)
  (check
    (define cl (cell 5))
    (cell? cl)
    (not (cell? 5))
    ((cell-of? number?) cl)
    (not ((cell-of? list?) cl))
    (= (cell-ref cl) 5)
    (cell-set! cl 50)
    (= (cell-ref cl) 50)
    ;(cell-set! cl 500)
    (set! (cell-ref cl) 500)
    (= (cell-ref cl) 500)
    (not (condition-case (cell-ref 500)
           ((exn) #f)))
    (set! (cell-ref cl) 5000)
    (= 5000 (cell-ref cl))
    ))

(define-test (STACKS)
  (check
    (define stack (cell '()))
    (cell? stack)
    ((cell-of? list?) stack)
    (not ((cell-of? number?) stack))
    (null? (stack))
    (push stack 5)
    (push stack 50)
    (push stack 500)
    (= 500 (top stack))
    (pop stack)
    (= 50 (top stack))
    (pop stack)
    (= 5 (top stack))))

(compound-test (cells)
  (TYPED_CELLS)
  (CELLS)
  (STACKS)
  )