   then execute clojure.test/run-tests on both of the test namespaces."
   [& ns-list]
   (use 'clojure.test)
-  (let [test-ns-list
-          (for [curr-ns ns-list]
-            (let [curr-ns-test (symbol (str curr-ns "-test")) ]
-              (require curr-ns curr-ns-test :reload-all)
-              curr-ns-test )) 
+  (let [
+    test-ns-list    (for [curr-ns ns-list]
+                      (let [curr-ns-test (symbol (str curr-ns "-test")) ]
+                        (require curr-ns curr-ns-test :reload-all)
+                        curr-ns-test )) 
+    _ (println "------------------------------------------------------------")
+    test-result     (apply clojure.test/run-tests test-ns-list)
+    _ (println "------------------------------------------------------------")
+    _ (newline)
   ]
-    (apply clojure.test/run-tests test-ns-list) ))
+  nil ))
 

;           (for-now ...)

(defn test-all 
  "Convenience fn to reload a namespace & the corresponding test namespace from disk and
  execute tests i the REPL.  Assumes canonical project test file organization with
  parallel src/... & test/... directories, where a '-test' suffix is added to all src
  namespaces to generate the cooresponding test namespace.  Example:

     (catch Exception e# ~default) ))

(defmacro spy-first
  "[expr msg]
  Evaluates the expression (the first arg) and prints both msg and the result to stdout;
  returns the result of expr."
  [expr msg]
  `(let [out-val# ~expr]
      (println (str ~msg " => " out-val#))
      out-val# ))

(defmacro spy-last
  "[msg expr]
  Evaluates the expression (the last arg) and prints both msg and the result to stdout;
  returns the result of expr."
  [msg expr]
  `(let [out-val# ~expr]
      (println (str ~msg " => " out-val#))
      out-val# ))

(defmacro spy-expr
  "[expr]
  Evaluates the expression and prints both expr and its result to stdout; 
  returns the result of expr."
  [expr]
  `(let [out-val# ~expr] 
      (println (str '~expr " => " out-val#)) 
      out-val#) )

(defmacro spy-val
  "[expr]
  Evaluates the expression and prints its result to stdout; 
  returns the result of expr."
  [expr]
  `(let [out-val# ~expr]
      (println out-val#)
