anchor.diff:      (is (acquire-recursive-lock lock :wait nil))
       (is (recursive-lock-p (release-recursive-lock lock)))))
   
  -#+#.(bt2::implemented-p* 'bt2:acquire-recursive-lock)
  +#+#.(bt2::implemented-p* 'bt2:with-recursive-lock-held)
   (test acquire-recursive-lock.try-lock
     (let ((lock (make-recursive-lock)))
       (make-thread (lambda ()
  -                   (acquire-recursive-lock lock)
  -                   (sleep 60)))
  -    (sleep 3)
  +                   (with-recursive-lock-held (lock)
  +                     (sleep 5)))
  +                 :name "acquire-recursive-lock.try-lock")
  +    (sleep 1)
       (is-false (acquire-recursive-lock lock :wait nil))))
   
  -#+#.(bt2::implemented-p* 'bt2:acquire-recursive-lock)
  +#+#.(bt2::implemented-p* 'bt2:with-recursive-lock-held)
   (test acquire-recursive-lock.timeout-expires
     (let ((lock (make-recursive-lock)))
       (make-thread (lambda ()
  -                   (acquire-recursive-lock lock)
  -                   (sleep 60)))
  -    (sleep 3)
  +                   (with-recursive-lock-held (lock)
  +                     (sleep 5)))
  +                 :name "acquire-recursive-lock.timeout-expires")
  +    (sleep 1)
       (is (null (acquire-recursive-lock lock :timeout .1)))))
   
   (test with-recursive-lock-held.timeout-no-contention-acquired
     (let ((lock (make-recursive-lock)))
       (is (eql :ok (with-recursive-lock-held (lock :timeout .1) :ok)))))
   
  -#+#.(bt2::implemented-p* 'bt2:acquire-recursive-lock)
  +#+#.(bt2::implemented-p* 'bt2:with-recursive-lock-held)
   (test with-recursive-lock-held.timeout-expires
     (let ((lock (make-recursive-lock)))
       (make-thread (lambda ()
  -                   (acquire-recursive-lock lock)
  -                   (sleep 60)))
  +                   (with-recursive-lock-held (lock)
  +                     (sleep 5)))
  +                 :name "with-recursive-lock-held.timeout-expires")
       (sleep 1)
       (is (eql :timeout
                (block ok
  
positive.code:                             (add-result :enter)
                              (sleep 1)
                              (add-result :leave))
                         (release-recursive-lock test-lock)))))
                threads)))
      (map 'nil #'join-thread threads)
      (is (equalp results #(:enter :leave :enter :leave)))))
  
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
  