anchor.diff:  
   ;;; Run the tests
   
  +(defclass test-result ()
  +  ((pass
  +    :type list
  +    :initarg :pass
  +    :reader pass)
  +   (fail
  +    :type list
  +    :initarg :fail
  +    :reader fail)
  +   (exerr
  +    :type condition
  +    :initarg :exerr
  +    :reader exerr))
  +  (:default-initargs :exerr nil)
  +  (:documentation
  +   "Store the results of the unit test."))
  +
   (defun run-code (code)
     "Run the code to test the assertions."
     (funcall (coerce `(lambda () ,@code) 'function)))
   
   (defun run-test-thunk (code)
  -  (let ((*pass* 0)
  -        (*fail* 0))
  +  (let ((*pass* ())
  +        (*fail* ()))
       (handler-bind
  -        ((error (lambda (condition)
  -                  (when *print-errors*
  -                    (print-error condition))
  -                  (if (use-debugger-p condition)
  -                      condition
  -                      (return-from run-test-thunk
  -                        (values *pass* *fail* condition))))))
  +        ((error
  +          (lambda (condition)
  +            (if (use-debugger-p condition)
  +                condition
  +                (return-from run-test-thunk
  +                  (make-instance
  +                   'test-result
  +                   :pass *pass*
  +                   :fail *fail*
  +                   :exerr condition))))))
         (run-code code))
       ;; Return the result count
  -    (values *pass* *fail* nil)))
  +    (make-instance 'test-result
  +                   :pass *pass*
  +                   :fail *fail*)))
   
   (defun %run-all-thunks (&optional (package *package*))
     "Run all of the test thunks in the package."
     (loop
  -   with results = (make-instance 'test-results)
  +   with results = (make-instance 'test-results-db)
      for test-name being each hash-key in (package-table package)
      using (hash-value unit-test)
      if unit-test do
  
positive.code: (defun print-summary (name pass fail &optional exerr)
    "Print a summary of the test results."
    (format t "~&~A: ~S assertions passed, ~S failed"
            name pass fail)
    (format t "~@[, ~S execution errors~].~2%" exerr))
  
  ;;; Global unit test database
  
negative.code: 
  ;;; Global counters
  
  (defparameter *pass* ()
    "The passed assertion results.")
  
  (defparameter *fail* ()
    "The failed assertion results.")
  
  ;;; Global options
  
  (defparameter *print-summary* nil
    "Print a summary of the pass, fail, and error count if non-nil.")
  