(use test)
(use srfi-18)

;;

(test-begin "thread-utils")

(use thread-utils)

(test-group "thread-timeout"
  (test-assert "timeout? #f" (thread-timeout? #f))
  (test-assert "timeout? time" (thread-timeout? (current-time)))
  (test-assert "timeout? #" (thread-timeout? 5))
  (test-assert "timeout? X" (not (thread-timeout? 'X)))
  (test #f (make-thread-timeout #f))
  (let ((t (current-time)))
    (test "time (base ignored)" t (make-thread-timeout t 27)) )
  (let* ((b (current-time))
         (t (make-thread-timeout 5 b)) )
    (test "# w/ time base" (+ 5 (time->seconds b)) (time->seconds t)) )
  (let* ((b 5)
         (t (make-thread-timeout 5 b)) )
    (test "# w/ # base" (+ 5 b) (inexact->exact (time->seconds t))) )
  (test-error "bad offset" (make-thread-timeout ""))
  (test-error "bad base" (make-thread-timeout 5 ""))
)

;;

(test-group "thread-... access"
  (let (
      (thgs (list
        thread-thunk
        thread-result-list
        thread-block-timeout
        thread-state-buffer
        ;thread-name
        ;thread-end-exception
        thread-owned-mutexes
        ;thread-quantum
        ;thread-specific
        thread-block-object
        thread-recipients
        thread-dynamic-winds
        thread-standard-input
        thread-standard-output
        thread-standard-error
        thread-default-exception-handler
        thread-current-parameter-vector
        thread-block-object-of-recipient?) )
      (th
        (make-thread (lambda () (void))) ) )
    (for-each
      (lambda (x)
        (test-assert (not (eq? (void) (x th)))) )
      thgs)
    (test-assert (thread-end-exception th))
  )
)

(test-end "thread-utils")

;;

(test-begin "thread-reaper")

(use thread-reaper)

(test #f (thread-reaper-shutdown?))

(test-group "thread reaping"
  (let (
    (th
      (thread-start!
        ;immediately stops , so can be reaped
        ;FIXME need test that has loop-time & wait-time before shutdown
        (lambda () (void) ) ) ) )
    (test-assert (thread-reap! th)) )
  (test-assert (not (thread-reaper-shutdown?)))
  (test (void) (thread-reaper-stop!))
)

(test-group "thread-reaper access"

  (test #f (thread-reaper-greedy))
  (thread-reaper-greedy-set! #t)
  (test #t (thread-reaper-greedy))

  (test 1.0 (thread-reaper-wait-seconds))
  (thread-reaper-wait-seconds-set! 2.0)
  (test 2.0 (thread-reaper-wait-seconds))

  (test #f (thread-reaper-timeout))
  (thread-reaper-timeout-set! 2.0)
  (test 2.0 (thread-reaper-timeout))

  (test 1 (thread-reaper-retries))
  (thread-reaper-retries-set! 2)
  (test 2 (thread-reaper-retries))
)

(test-end "thread-reaper")

;;;

(test-exit)