        (update-current-env! [:testing-vars] conj v)
        (update-current-env! [:report-counters :test] inc)
        (do-report {:type :begin-test-var :var v})
-       (let [{:keys [async-disabled]} (get-current-env)]
-         (cond-> (try
-                   (t)
-                   (catch :default e
-                     (do-report
-                      {:type :error
-                       :message "Uncaught exception, not in assertion."
-                       :expected nil
-                       :actual e})))
-           async-disabled (-> async? not (assert async-disabled)))))
+       (try
+         (t)
+         (catch :default e
+           (do-report
+             {:type :error
+              :message "Uncaught exception, not in assertion."
+              :expected nil
+              :actual e}))))
      (fn []
        (do-report {:type :end-test-var :var v})
        (update-current-env! [:testing-vars] rest))]))

          block
          (reverse (keep :after map-fixtures))))

(defn- fixtures-type
  [coll]
  (cond (empty? coll)
        :none
        (every? map? coll)
        :map
        (every? fn? coll)
        :fn))

(defn- execution-strategy
  [once-fixtures each-fixtures]
  (let [types (map fixtures-type [once-fixtures each-fixtures])
        _ (assert (not-any? nil? types)
                  "Fixtures may not be of mixed types")
        types (->> types
                   (remove #{:none})
                   (distinct))
        _ (assert (> 2 (count types)) "fixtures specified in :once and :each must be of the same type")]
    (case (first types)
      :map :async
      :fn :sync
      nil :async)))

(defn test-vars-block
  "Like test-vars, but returns a block for further composition and

                        (when (:test (meta v))
                          (each-fixture-fn
                           (fn []
                             (test-var v))))))))])))))))
   (group-by (comp :ns meta) vars)))

(defn test-vars
