           (deliver outside-pool pool)
           ;; Use a future to avoid blocking on the :serial case.
           (deliver fp (future (.submit pool #(deref start))))
-          (Thread/sleep 50))
+          (Thread/sleep 100))
         ;; Make sure outside of the with-shutdown block the pool is properly
         ;; killed.
         (when-not (keyword? arg) (is (true? (cp/shutdown? @outside-pool)))
-          (Thread/sleep 50)
+          (Thread/sleep 100)
           (is (true? (.isTerminated @outside-pool)))
           (deliver start true)
-          (Thread/sleep 50)
+          (Thread/sleep 100)
           (is (.isDone @@fp))
           (is (thrown? ExecutionException (deref @@fp)))))))
   (testing "With-shutdown! works with any number of threadpools"

        (cp/future (cp/with-priority pool 7)
                   (run 7))
        ;; Make them go.
        (Thread/sleep 50)
        (deliver start true)
        ;; Check the results
        (Thread/sleep 50)
        (is (sorted*? (reverse @results)))))))

(deftest test-threadpool?

                                   (deliver (promise-chain (inc i)) i))
                                 i)
                               input)]
        ;; All tasks should have started after 100ms.
        (Thread/sleep 100)
        (is (= @started (set input)))
        ;; Start the first task.
        (deliver (first promise-chain) nil)
