 (def t7 (TestCase [c6] [a3 a4]))
 
 (with-log
-  (let [results (run-test-case t7)]
+  (let [results (run-test-case t7 {} lazy-strategy)]
     (assert (= @*log* [:c6-open]))
     (dorun (result-seq results))
     (assert (= @*log* [:c6-open :a3 :a4]))))

      (some has-after? (:parents c))))

(defn run-test-case
  "Executes a test case in context."
  ([t] (run-test-case t {}))
  ([t active]
     {:pre [(= ::TestCase (type t))
            (every? #(= ::Context (type %)) (:contexts t))]}
     (try
      (let [merged (reduce open-context active (:contexts t))
            states (map merged (:contexts t))
            ;; Prevent chunking for truly lazy execution:
            results (unchunked-map #(invoke-test % states merged)
                                   (:children t))]
        ;; Force non-lazy execution to handle shutdown properly:
        (when (some has-after? (:contexts t))
          (dorun results)

(def t8 (TestCase [] [t7 t7]))

(with-log
  (let [results (run-test-case t8 {} lazy-strategy)]
    (assert (= @*log* []))
    (dorun (:children (first (:children results))))
    (assert (= @*log* [:c6-open :a3 :a4]))
