anchor.diff:      (is (eql 'interrupted (join-thread thread)))))
   
   (test thread-alive-p.new-thread
  -  (is (thread-alive-p (make-thread (lambda () (sleep 60))))))
  +  (is (thread-alive-p (make-thread (lambda () (sleep 60))
  +                                   :name "thread-alive-p.new-thread"))))
   
   #+#.(bt2::implemented-p* 'bt2:destroy-thread)
   (test destroy-thread.terminates
  -  (let ((thread (make-thread (lambda () (sleep 3)))))
  +  (let ((thread (make-thread (lambda () (sleep 3))
  +                             :name "destroy-thread.terminates")))
       (is (threadp (destroy-thread thread)))
       (sleep 5)
       (is-false (thread-alive-p thread))))
   
   #+sbcl
   (test destroy-thread.join-error
  -  (let ((thread (make-thread (lambda () (sleep 3)))))
  +  (let ((thread (make-thread (lambda () (sleep 3))
  +                             :name "destroy-thread.join-error")))
       (destroy-thread thread)
       (signals error (join-thread thread))))
   
positive.code:   (is (every #'threadp (all-threads))))
  
  (test all-threads.contains-new-thread
    (let ((thread (make-thread (lambda () (sleep 60)))))
      (is (find thread (all-threads)))))
  
  #+#.(bt2::implemented-p* 'bt2:interrupt-thread)
  
negative.code: (test acquire-lock.try-lock
    (let ((lock (make-lock)))
      (make-thread (lambda ()
                     (with-lock-held (lock)
                       (sleep 5)))
                   :name "acquire-lock.try-lock")
      (sleep 1)
      (is-false (acquire-lock lock :wait nil))))
  
  (test acquire-lock.timeout-expires
    (let ((lock (make-lock)))
      (make-thread (lambda ()
                     (with-lock-held (lock)
                       (sleep 5)))
                   :name "acquire-lock.timeout-expires")
      (sleep 1)
      (is (null (acquire-lock lock :timeout .1)))))
  
  (test with-lock-held.timeout-no-contention-acquired
    (let ((lock (make-lock)))
      (is (eql :ok (with-lock-held (lock :timeout .1) :ok)))))
  
  #+#.(bt2::implemented-p* 'bt2:with-lock-held)
  (test with-lock-held.timeout-expires
    (let ((lock (make-lock)))
      (make-thread (lambda ()
                     (with-lock-held (lock)
                       (sleep 5)))
                   :name "with-lock-held.timeout-expires")
      (sleep 1)
      (is (eql :timeout
               (block ok
  