;;;; stack-test

(require-extension test)
(require-extension stack)

(test-group "Empty Stack" 
  (test-assert (make-stack))
  (test-assert (stack? (make-stack)))
  (test-assert (stack-empty? (make-stack)))
  (test 0 (stack-count (make-stack)))
)

(test-group "Push!/Pop!/Peek/Poke!"
  (let ([stk (make-stack)])
    (stack-push! stk 1)
    (stack-push! stk 2 3)
    (test 3 (stack-count stk))
    (test 3 (stack-pop! stk))
    (test 2 (stack-pop! stk))
    (test 1 (stack-pop! stk))
    (test-assert (stack-empty? stk))
    (test-error (stack-pop! stk))
    (stack-push! stk 1 2 3)
    (test 2 (stack-peek stk 1))
    (stack-poke! stk 4 1)
    (test 3 (stack-pop! stk))
    (test 4 (stack-pop! stk))
    (test 1 (stack-count stk)) )
)

(test-group "Cut!"
  (let ([stk (make-stack)])
    ;3 2 1
    (stack-push! stk 1 2 3)
    (test '(2) (stack-cut! stk 1 2))
    (test 2 (stack-count stk))
    ;3 1
    (test '(3) (stack-cut! stk 0 1))
    (test 1 (stack-count stk))
    ;5 4 1
    (stack-push! stk 4 5)
    (test '(4 1) (stack-cut! stk 1 3))
    (test 1 (stack-count stk))
    ;
    (test-error (stack-cut! stk -1 3))
    (test-error (stack-cut! stk 0 3))
    (test-error (stack-cut! stk 0 -3)) )
)

(test-group "Stack from List"
  (let ([stk (make-stack)]
        [stk1 (list->stack '(1 2 3))])
    ;
    (stack-push! stk 1 2 3)
    (test '(3 2 1) (stack->list stk))
    ;
    (test-assert (stack? stk1))
    (test 3 (stack-count stk1))
    (test 1 (stack-pop! stk1)) )
)