anchor.diff:        (incf (exerr results))
         (push test-name (error-tests results)))
       ;; Running output
  -    (when *print-failures* (print-failure result))
  -    (when *print-errors* (print-error result))))
  +    (when *print-failures* (print-failures result))
  +    (when *print-errors* (print-errors result))
  +    (when (or *print-summary* *print-failures* *print-errors*)
  +      (print-summary result))))
   
   (defun summarize-results (results)
     "Print a summary of all results."
  
positive.code:   (format t "~& |~%")
    (class-name (class-of result)))
  
  (defmethod print-failure ((result assert-result))
    (format t "~& | Expected ~{~S~^; ~} " (expected result))
    (format t "~<~% | ~:;but saw ~{~S~^; ~}~>" (actual result)))
  
  (defmethod print-failure ((result error-result))
    (format t "~& | ~@[Should have signalled ~{~S~^; ~} but saw~]"
            (expected result))
    (format t " ~{~S~^; ~}" (actual result)))
  
  (defmethod print-failure ((result macro-result))
    (format t "~& | Should have expanded to ~{~S~^; ~} "
            (expected result))
    (format t "~<~%~:;but saw ~{~S~^; ~}~>" (actual result)))
  
  (defmethod print-failure ((result output-result))
    (format t "~& | Should have printed ~{~S~^; ~} "
            (expected result))
    (format t "~<~%~:;but saw ~{~S~^; ~}~>"
            (actual result)))
  
  (defmethod print-failure ((result test-result))
    "Print the failed assertions in the unit test."
    (loop for fail in (fail result) do
          (print-failure fail)
          finally
          (print-summary result)))
  
  (defmethod print-failure ((results test-results-db))
    "Print all of the failure tests."
    (loop with db = (database results)
          for test in (failed-tests results) do
          (print-failure (gethash test db))))
  
  ;;; Print errors
  
  (defgeneric print-error (result)
    (:documentation
     "Print the error condition."))
  
  (defmethod print-error ((result test-result))
    "Print the error condition."
    (let ((exerr (exerr result))
          (*print-escape* nil))
      (when exerr
        (format t "~& | Execution error:~% | ~W" (exerr result))
        (format t "~& |~%"))
      (print-summary result)))
  
  (defmethod print-error ((results test-results-db))
    "Print all of the error tests."
    (loop with db = (database results)
          for test in (error-tests results) do
          (print-error (gethash test db))))
  
  ;;; Useful equality predicates for tests
  
  
negative.code: 
  ;;; Print failures
  
  (defgeneric print-failures (result)
    (:documentation
     "Report the results of the failed assertion."))
  
  (defmethod print-failures :around ((result assert-result))
    "Failure header and footer output."
    (format t "~& | Failed Form: ~S" (form result))
    (call-next-method)
  