-(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)))))
+#+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)))))
+
+(with-test (:name (:condition-wait :timeout :one-thread))
+ (let ((mutex (make-mutex))
+ (waitqueue (make-waitqueue)))
+ (assert (not (with-mutex (mutex)
+ (condition-wait waitqueue mutex :timeout 0.01))))))
+
+(with-test (:name (:condition-wait :timeout :many-threads)
+ :skipped-on '(not :sb-thread))
+ (let* ((mutex (make-mutex))
+ (waitqueue (make-waitqueue))
+ (sem (make-semaphore))
+ (data nil)
+ (workers
+ (loop repeat 100
+ collect (make-thread
+ (lambda ()
+ (wait-on-semaphore sem)
+ (block thread
+ (with-mutex (mutex)
+ (loop until data
+ do (or (condition-wait waitqueue mutex :timeout 0.01)
+ (return-from thread nil)))
+ (assert (eq t (pop data)))
+ t)))))))
+ (loop repeat 50
+ do (with-mutex (mutex)
+ (push t data)
+ (condition-notify waitqueue)))
+ (signal-semaphore sem 100)
+ (let ((ok (count-if #'join-thread workers)))
+ (unless (eql 50 ok)
+ (error "Wanted 50, got ~S" ok)))))
+
+(with-test (:name (:wait-on-semaphore :timeout :one-thread))
+ (let ((sem (make-semaphore))
+ (n 0))
+ (signal-semaphore sem 10)
+ (loop repeat 100
+ do (when (wait-on-semaphore sem :timeout 0.001)
+ (incf n)))
+ (assert (= n 10))))
+
+(with-test (:name (:wait-on-semaphore :timeout :many-threads)
+ :skipped-on '(not :sb-thread))
+ (let* ((sem (make-semaphore))
+ (threads
+ (progn
+ (signal-semaphore sem 10)
+ (loop repeat 100
+ collect (make-thread
+ (lambda ()
+ (sleep (random 0.02))
+ (wait-on-semaphore sem :timeout 0.5)))))))
+ (loop repeat 5
+ do (signal-semaphore sem 2))
+ (let ((ok (count-if #'join-thread threads)))
+ (unless (eql 20 ok)
+ (error "Wanted 20, got ~S" ok)))))
+
+(with-test (:name (:join-thread :timeout)
+ :skipped-on '(not :sb-thread))
+ (assert (eq :error
+ (handler-case
+ (join-thread (make-join-thread (lambda () (sleep 10))) :timeout 0.01)
+ (join-thread-error ()
+ :error))))
+ (let ((cookie (cons t t)))
+ (assert (eq cookie
+ (join-thread (make-join-thread (lambda () (sleep 10)))
+ :timeout 0.01
+ :default cookie)))))
+
+(with-test (:name (:semaphore-notification :wait-on-semaphore)
+ :skipped-on '(not :sb-thread))
+ (let ((sem (make-semaphore))
+ (ok nil)
+ (n 0))
+ (flet ((critical ()
+ (let ((note (make-semaphore-notification)))
+ (sb-sys:without-interrupts
+ (unwind-protect
+ (progn
+ (sb-sys:with-local-interrupts
+ (wait-on-semaphore sem :notification note)
+ (sleep (random 0.1)))
+ (incf n))
+ ;; Re-increment on exit if we decremented it.
+ (when (semaphore-notification-status note)
+ (signal-semaphore sem))
+ ;; KLUDGE: Prevent interrupts after this point from
+ ;; unwinding us, so that we can reason about the counts.
+ #+sb-thread
+ (sb-thread::block-deferrable-signals))))))
+ (let* ((threads (loop for i from 1 upto 100
+ collect (make-join-thread #'critical :name (format nil "T~A" i))))
+ (safe nil)
+ (unsafe nil)
+ (interruptor (make-thread (lambda ()
+ (loop until ok)
+ (let (x)
+ (dolist (thread threads)
+ (cond (x
+ (push thread unsafe)
+ (sleep (random 0.1))
+ (ignore-errors
+ (terminate-thread thread)))
+ (t
+ (push thread safe)))
+ (setf x (not x))))))))
+ (signal-semaphore sem)
+ (setf ok t)
+ (join-thread interruptor)
+ (mapc #'join-thread safe)
+ (let ((k (count-if (lambda (th)
+ (join-thread th :default nil))
+ unsafe)))
+ (assert (= n (+ k (length safe))))
+ (assert unsafe))))))
+
+(with-test (:name (:semaphore-notification :try-sempahore)
+ :skipped-on '(not :sb-thread))
+ (let* ((sem (make-semaphore))
+ (note (make-semaphore-notification)))
+ (try-semaphore sem 1 note)
+ (assert (not (semaphore-notification-status note)))
+ (signal-semaphore sem)
+ (try-semaphore sem 1 note)
+ (assert (semaphore-notification-status note))))
+
+(with-test (:name (:return-from-thread :normal-thread)
+ :skipped-on '(not :sb-thread))
+ (let* ((thread (make-thread (lambda ()
+ (return-from-thread (values 1 2 3))
+ :foo)))
+ (values (multiple-value-list (join-thread thread))))
+ (unless (equal (list 1 2 3) values)
+ (error "got ~S, wanted (1 2 3)" values))))
+
+(with-test (:name (:return-from-thread :main-thread))
+ (assert (main-thread-p))
+ (assert (eq :oops
+ (handler-case
+ (return-from-thread t)
+ (thread-error ()
+ :oops)))))
+
+(with-test (:name (:abort-thread :normal-thread)
+ :skipped-on '(not :sb-thread))
+ (let ((thread (make-thread (lambda ()
+ (abort-thread)
+ :foo))))
+ (assert (eq :aborted! (join-thread thread :default :aborted!)))))
+
+(with-test (:name (:abort-thread :main-thread))
+ (assert (main-thread-p))
+ (assert (eq :oops
+ (handler-case
+ (abort-thread)
+ (thread-error ()
+ :oops)))))