anchor.diff:    "Repeatedly call TEST-FN with VARS bound to values from GENERATORS."
     (let ((status (make-hash-table :test #'equal)))
       (let-dfv ((*logger* (test)
  -	        (let ((name (test-name test)))
  -		  (setf (gethash name status) 
  -			(tally test (gethash name status 0)))
  -		  (call-next-function test))))
  +                (let ((name (test-name test)))
  +                  (setf (gethash name status)
  +                        (tally test (gethash name status 0)))
  +                  (call-next-function test))))
         (loop repeat (* 4 *num-trials*)
  -	    do (run-trial test-fn vars generators)
  -	    until (every #'judgedp (hash-table-values status))))))
  +            do (run-trial test-fn vars generators)
  +            until (every #'judgedp (hash-table-values status))))))
   ; TODO: we should record at this time whether a test passed
   ; *num-trials* times, rather than checking afterwards when
   ; *num-trials* could have a different value.
  
positive.code: (defun collect-test-results (fn)
    "Call FN with *TESTING* true, and return a list of the test results."
    (let ((tests '())
  	(*testing* t))
      (let-dfv ((*logger* (test) 
  		(push test tests) 
  		test))
        (funcall fn))
      (nreverse tests)))
  
  
negative.code:       (funcall fn)))
  
    (defmacro wrap-each (wrapper &body wrappees)
      "Perform each of the WRAPPEES as if surrounded by WRAPPER (with
  the literal symbol WRAPPEE inside WRAPPER being the hole where the
  wrappee appears).  This is useful for factoring out common setup/teardown
  code for a sequence of tests without compromising their isolation."
      ;; TODO: use a macrolet for a cleaner expansion?  Make wrappee a
      ;; parameter?
      `(progn ,@(mapcar (lambda (wrappee)
                          `(symbol-macrolet ((wrappee ,wrappee))
                             ,wrapper))
                        wrappees)))
  
    (defmacro only-if (flag test)
      "Perform the TEST only if FLAG is true, otherwise return a SKIPPED
  