 (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]))))

  (run-tests [x] "Runs tests defined for the Namespace, Var, or TestCase."))

(defprotocol TestInvokable
  (invoke-test [t states active]
               "(private) Executes the TestCase or Assertion."))

(extend-class clojure.lang.Fn TestInvokable
              (invoke-test [f states active] (apply f states)))

;;; DATATYPES


                      '~m))))))


;;; TEST RUNNING STRATEGIES

(defn- map1
  "Like map but does not chunk results; slower but lazier than map."
  [f coll]
  (lazy-seq
   (when (seq coll)
     (cons (f (first coll))
           (map1 f (next coll))))))

(defn default-strategy []
  "Default test execution strategy; uses (chunked) map."
  [map default-strategy])

(defn lazy-strategy []
  "Truly lazy test execution strategy; uses (unchunked) map1."
  [map1 lazy-strategy])

(defn parallel-strategy []
  [pmap parallel-strategy])

(defn parallel-upto
  "Returns a strategy that is parallel up to n levels of recursion,
  then reverts to default-strategy."
  [n]
  (if (zero? n)
    default-strategy
    [pmap #(parallel-upto (dec n))]))


;;; TEST CASE HANDLING

(defn- has-after?
  "True if Context c or any of its parents has an :after function."
