anchor.diff:                               ,@format-arguments)))))
   
   
  +
  +(defmacro testing (&body body)
  +  `(multiple-value-bind (successes failures)
  +       (let ((*success-count* 0)
  +             (*failure-count* 0)
  +             (*current-test-printed-p*  nil))
  +         (progress-start)
  +         (progn ,@body)
  +         (progress-tally *success-count* *failure-count*)
  +         (values *success-count* *failure-count*))
  +     (incf *success-count* successes)
  +     (incf *failure-count* failures)
  +     (if (zerop failures)
  +         :success
  +         :failure)))
  +
  +
   (defmacro define-test (name parameters &body body)
     "Like DEFUN, but wraps the body in test reporting boilerplate."
     (let ((mandatory (loop
  
positive.code:     (if *last-success-p*
          (format *test-output* "~A" (aref *report-string* (1- (length *report-string*))))
          (format *test-output* "~&~A" *report-string*))
      (finish-output *test-output*))
    (values))
  
  
  
negative.code:       `(defun ,name ,parameters
           ,@docstrings
           ,@declarations
           (let ((*current-test-name*        ',name)
                 (*current-test-parameters* (list ,@mandatory)))
             (testing ,@forms))))))
  
  (defmacro with-debugger-on-error (&body body)
    `(let ((*debug-on-error* t))
  