;;;;                                                          -*- scheme -*-
;;;; continuations.test --- test suite for continutations
;;;;
;;;; Copyright (C) 2003, 2006, 2009, 2011 Free Software Foundation, Inc.
;;;; 
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 3 of the License, or (at your option) any later version.
;;;; 
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;;; Lesser General Public License for more details.
;;;; 
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

(define-module (test-suite test-continuations)
  :use-module (test-suite lib))

(define (block-reentry body)
  (let ((active #f))
    (dynamic-wind
	(lambda () 
	  (if active
	      (throw 'no-reentry)))
	(lambda ()
	  (set! active #t)
	  (body))
	(lambda () #f))))

(define (catch-tag body)
  (catch #t
	 body
	 (lambda (tag . args) tag)))

(define (check-cont)
  (catch-tag 
   (lambda ()
     (block-reentry (lambda () (call/cc identity))))))

(define (dont-crash-please)
  (let ((k (check-cont)))
    (if (procedure? k)
	(k 12)
	k)))

(with-test-prefix "continuations"

  (pass-if "throwing to a rewound catch context"
    (eq? (dont-crash-please) 'no-reentry))

  (pass-if "can print a continuation"
    (let ((s (with-output-to-string
	       (lambda ()
		 (call-with-current-continuation write)))))
      (string=? "#<continuation " (substring s 0 15))))

  (pass-if "blocked attempt to cross a continuation barrier"
    (call-with-current-continuation
     (lambda (k)
       (with-continuation-barrier
	(lambda ()
	  (catch 'misc-error
		 (lambda ()
		   (k 1)
		   #f)
		 (lambda _
		   #t)))))))

  (pass-if "uncaught exception is handled by continuation barrier"
    (let* ((handled #f)
	   (s (with-error-to-string
	       (lambda ()
		 (set! handled
		       (not (with-continuation-barrier
			     (lambda ()
			       (error "Catch me if you can!")))))))))
      handled))

  (pass-if "exit unwinds dynwinds inside a continuation barrier"
    (let ((s (with-error-to-string
              (lambda ()
                (with-continuation-barrier
                 (lambda ()
                   (dynamic-wind 
                     (lambda () #f)
                     (lambda () (exit 1))
                     (lambda () (throw 'abcde)))))))))
      (and (string-contains s "abcde") #t)))

  (with-debugging-evaluator

    (pass-if "make a stack from a continuation"
      (stack? (call-with-current-continuation make-stack)))

    (pass-if "get a continuation's stack ID"
      (let ((id (call-with-current-continuation stack-id)))
	(or (boolean? id) (symbol? id)))))

)