 (defmulti my-report :type)
 
 (defmethod my-report :pass [m]
-  (update-results *out* (dissoc m :actual)))
+  (update-results *string-writer* (dissoc m :actual)))
 
 (defmethod my-report :fail [m]
-  (update-results *out* m))
+  (update-results *string-writer* m))
 
 (defmethod my-report :error [m]
-  (update-results *out* (update-in m [:actual] parse-exception)))
+  (update-results *string-writer* (update-in m [:actual] parse-exception)))
 
 (defmethod my-report :begin-test-var [m]
   (set! *current-test* (:name (meta (:var m))))
   (reset-streams!))
 
 (defmethod my-report :end-test-var [m]
-  (update-results *out*)
+  (update-results *string-writer*)
   (set! *current-test* nil))
 
 (defn run-ns-tests [ns tests]

                                    (ns-publics ns)))))
            {} nses)))

(def ^:dynamic *ns-results*)
(def ^:dynamic *current-test*)

(defn reset-streams! []
  (set! *out* (StringWriter.))
  (set! *err* *out*))

(defn unprintable? [obj]

              *test-out* (StringWriter.)
              *out* *out* ;; this is so it gets restored
              *err* *err*
              *string-writer* nil
              *report-counters* (ref *initial-report-counters*)
              *ns-results* (atom {})
              *current-test* nil]
