+ (assert (equal (list :write :thread-dead)
+ (sb-thread::symbol-value-in-thread-error-info e)))))
+ (assert error-occurred)))
+
+(with-test (:name deadlock-detection.1 :skipped-on '(not :sb-thread))
+ (loop
+ repeat 1000
+ do (flet ((test (ma mb sa sb)
+ (lambda ()
+ (handler-case
+ (sb-thread:with-mutex (ma)
+ (sb-thread:signal-semaphore sa)
+ (sb-thread:wait-on-semaphore sb)
+ (sb-thread:with-mutex (mb)
+ :ok))
+ (sb-thread:thread-deadlock (e)
+ (princ e)
+ :deadlock)))))
+ (let* ((m1 (sb-thread:make-mutex :name "M1"))
+ (m2 (sb-thread:make-mutex :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread (test m1 m2 s1 s2) :name "T1"))
+ (t2 (sb-thread:make-thread (test m2 m1 s2 s1) :name "T2")))
+ ;; One will deadlock, and the other will then complete normally.
+ ;; ...except sometimes, when we get unlucky, and both will do
+ ;; the deadlock detection in parallel and both signal.
+ (let ((res (list (sb-thread:join-thread t1)
+ (sb-thread:join-thread t2))))
+ (assert (or (equal '(:deadlock :ok) res)
+ (equal '(:ok :deadlock) res)
+ (equal '(:deadlock :deadlock) res))))))))
+
+(with-test (:name deadlock-detection.2 :skipped-on '(not :sb-thread))
+ (let* ((m1 (sb-thread:make-mutex :name "M1"))
+ (m2 (sb-thread:make-mutex :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread
+ (lambda ()
+ (sb-thread:with-mutex (m1)
+ (sb-thread:signal-semaphore s1)
+ (sb-thread:wait-on-semaphore s2)
+ (sb-thread:with-mutex (m2)
+ :ok)))
+ :name "T1")))
+ (prog (err)
+ :retry
+ (handler-bind ((sb-thread:thread-deadlock
+ (lambda (e)
+ (unless err
+ ;; Make sure we can print the condition
+ ;; while it's active
+ (let ((*print-circle* nil))
+ (setf err (princ-to-string e)))
+ (go :retry)))))
+ (when err
+ (sleep 1))
+ (assert (eq :ok (sb-thread:with-mutex (m2)
+ (unless err
+ (sb-thread:signal-semaphore s2)
+ (sb-thread:wait-on-semaphore s1)
+ (sleep 1))
+ (sb-thread:with-mutex (m1)
+ :ok)))))
+ (assert (stringp err)))
+ (assert (eq :ok (sb-thread:join-thread t1)))))
+
+(with-test (:name deadlock-detection.3 :skipped-on '(not :sb-thread))
+ (let* ((m1 (sb-thread:make-mutex :name "M1"))
+ (m2 (sb-thread:make-mutex :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread
+ (lambda ()
+ (sb-thread:with-mutex (m1)
+ (sb-thread:signal-semaphore s1)
+ (sb-thread:wait-on-semaphore s2)
+ (sb-thread:with-mutex (m2)
+ :ok)))
+ :name "T1")))
+ ;; Currently we don't consider it a deadlock
+ ;; if there is a timeout in the chain.
+ (assert (eq :deadline
+ (handler-case
+ (sb-thread:with-mutex (m2)
+ (sb-thread:signal-semaphore s2)
+ (sb-thread:wait-on-semaphore s1)
+ (sleep 1)
+ (sb-sys:with-deadline (:seconds 0.1)
+ (sb-thread:with-mutex (m1)
+ :ok)))
+ (sb-sys:deadline-timeout ()
+ :deadline)
+ (sb-thread:thread-deadlock ()
+ :deadlock))))
+ (assert (eq :ok (join-thread t1)))))
+
+(with-test (:name deadlock-detection.4 :skipped-on '(not :sb-thread))
+ (loop
+ repeat 1000
+ do (flet ((test (ma mb sa sb)
+ (lambda ()
+ (handler-case
+ (sb-thread::with-spinlock (ma)
+ (sb-thread:signal-semaphore sa)
+ (sb-thread:wait-on-semaphore sb)
+ (sb-thread::with-spinlock (mb)
+ :ok))
+ (sb-thread:thread-deadlock (e)
+ (princ e)
+ :deadlock)))))
+ (let* ((m1 (sb-thread::make-spinlock :name "M1"))
+ (m2 (sb-thread::make-spinlock :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread (test m1 m2 s1 s2) :name "T1"))
+ (t2 (sb-thread:make-thread (test m2 m1 s2 s1) :name "T2")))
+ ;; One will deadlock, and the other will then complete normally
+ ;; ...except sometimes, when we get unlucky, and both will do
+ ;; the deadlock detection in parallel and both signal.
+ (let ((res (list (sb-thread:join-thread t1)
+ (sb-thread:join-thread t2))))
+ (assert (or (equal '(:deadlock :ok) res)
+ (equal '(:ok :deadlock) res)
+ (equal '(:deadlock :deadlock) res))))))))
+
+(with-test (:name deadlock-detection.5 :skipped-on '(not :sb-thread))
+ (let* ((m1 (sb-thread::make-spinlock :name "M1"))
+ (m2 (sb-thread::make-spinlock :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread
+ (lambda ()
+ (sb-thread::with-spinlock (m1)
+ (sb-thread:signal-semaphore s1)
+ (sb-thread:wait-on-semaphore s2)
+ (sb-thread::with-spinlock (m2)
+ :ok)))
+ :name "T1")))
+ (prog (err)
+ :retry
+ (handler-bind ((sb-thread:thread-deadlock
+ (lambda (e)
+ (unless err
+ ;; Make sure we can print the condition
+ ;; while it's active
+ (let ((*print-circle* nil))
+ (setf err (princ-to-string e)))
+ (go :retry)))))
+ (when err
+ (sleep 1))
+ (assert (eq :ok (sb-thread::with-spinlock (m2)
+ (unless err
+ (sb-thread:signal-semaphore s2)
+ (sb-thread:wait-on-semaphore s1)
+ (sleep 1))
+ (sb-thread::with-spinlock (m1)
+ :ok)))))
+ (assert (stringp err)))
+ (assert (eq :ok (sb-thread:join-thread t1)))))
+
+(with-test (:name deadlock-detection.7 :skipped-on '(not :sb-thread))
+ (let* ((m1 (sb-thread::make-spinlock :name "M1"))
+ (m2 (sb-thread::make-spinlock :name "M2"))
+ (s1 (sb-thread:make-semaphore :name "S1"))
+ (s2 (sb-thread:make-semaphore :name "S2"))
+ (t1 (sb-thread:make-thread
+ (lambda ()
+ (sb-thread::with-spinlock (m1)
+ (sb-thread:signal-semaphore s1)
+ (sb-thread:wait-on-semaphore s2)
+ (sb-thread::with-spinlock (m2)
+ :ok)))
+ :name "T1")))
+ (assert (eq :deadlock
+ (handler-case
+ (sb-thread::with-spinlock (m2)
+ (sb-thread:signal-semaphore s2)
+ (sb-thread:wait-on-semaphore s1)
+ (sleep 1)
+ (sb-sys:with-deadline (:seconds 0.1)
+ (sb-thread::with-spinlock (m1)
+ :ok)))
+ (sb-sys:deadline-timeout ()
+ :deadline)
+ (sb-thread:thread-deadlock ()
+ :deadlock))))
+ (assert (eq :ok (join-thread t1)))))
+
+#+sb-thread
+(with-test (:name :pass-arguments-to-thread)
+ (assert (= 3 (join-thread (make-thread #'+ :arguments '(1 2))))))
+
+#+sb-thread
+(with-test (:name :pass-atom-to-thread)
+ (assert (= 1/2 (join-thread (make-thread #'/ :arguments 2)))))
+
+#+sb-thread
+(with-test (:name :pass-nil-to-thread)
+ (assert (= 1 (join-thread (make-thread #'* :arguments '())))))
+
+#+sb-thread
+(with-test (:name :pass-nothing-to-thread)
+ (assert (= 1 (join-thread (make-thread #'*)))))
+
+#+sb-thread
+(with-test (:name :pass-improper-list-to-thread)
+ (multiple-value-bind (value error)
+ (ignore-errors (make-thread #'+ :arguments '(1 . 1)))
+ (when value
+ (join-thread value))
+ (assert (and (null value)
+ error))))
+
+(with-test (:name (:wait-for :basics))
+ (assert (not (sb-ext:wait-for nil :timeout 0.1)))
+ (assert (eql 42 (sb-ext:wait-for 42)))
+ (let ((n 0))
+ (assert (eql 100 (sb-ext:wait-for (when (= 100 (incf n))
+ n))))))
+
+(with-test (:name (:wait-for :deadline))
+ (assert (eq :ok
+ (sb-sys:with-deadline (:seconds 10)
+ (assert (not (sb-ext:wait-for nil :timeout 0.1)))
+ :ok)))
+ (assert (eq :deadline
+ (handler-case
+ (sb-sys:with-deadline (:seconds 0.1)
+ (sb-ext:wait-for nil :timeout 10)
+ (error "oops"))
+ (sb-sys:deadline-timeout () :deadline)))))