anchor.diff:  
   (defpackage :lisp-unit
     (:use :common-lisp)
  +  ;; Forms for assertions
  +  (:export
  +   :assert-eq :assert-eql :assert-equal :assert-equalp
  +   :assert-equality :assert-prints :assert-expands
  +   :assert-true :assert-false :assert-error)
     ;; Functions for managing tests
     (:export
      :define-test
  
positive.code:         exit
          (return (values *test-count* *pass-count* error-count)))))
  
  (defun use-debugger-p (e)
    (and *use-debugger*
         (or (not (eql *use-debugger* :ask))
             (y-or-n-p "~A -- debug?" e))))
  
  ;;; OUTPUT support
  
  (defun get-failure-message (type)
    (case type
      (:error "~&~@[Should have signalled ~{~S~^; ~} but saw~] ~{~S~^; ~}")
      (:macro "~&Should have expanded to ~{~S~^; ~} ~<~%~:;but saw ~{~S~^; ~}~>")
      (:output "~&Should have printed ~{~S~^; ~} ~<~%~:;but saw ~{~S~^; ~}~>")
      (t "~&Expected ~{~S~^; ~} ~<~%~:;but saw ~{~S~^; ~}~>")))
  
  (defun show-failure (type msg name form expected actual extras)
    (format t "~&~@[~S: ~]~S failed: " name form)
    (format t msg expected actual)
    (format t "~{~&   ~S => ~S~}~%" extras)
    type)
  
  (defun show-summary (name test-count pass-count &optional error-count)
    (format t "~&~A: ~S assertions passed, ~S failed~@[, ~S execution errors~]."
            name pass-count (- test-count pass-count) error-count))
  
  (defun collect-form-values (form values)
    (mapcan (lambda (form-arg value)
  
negative.code:    :run-tests :run-all-tests
     :use-debugger
     :with-test-listener)
    ;; Utility predicates
    (:export
     :logically-equal :set-equal))
  
  (in-package :lisp-unit)
  
  ;;; Global counters
  
  (defparameter *pass* 0
    "The number of passed assertions.")
  
  (defparameter *fail* 0
    "The number of failed assertions.")
  
  ;;; Global options
  
  (defparameter *report-results* nil
    "If not NIL, report the results of the assertions.")
  
  ;;; Global unit test database
  
  (defparameter *test-db* (make-hash-table :test #'eq)
    "The unit test database is simply a hash table.")
  
  (defun package-table (package &optional create)
    (cond
     ((gethash (find-package package) *test-db*))
     (create
      (setf (gethash package *test-db*) (make-hash-table)))))
  
  (defmacro define-test (name &body body)
    "Store the test in the test database."
    `(progn
       (setf
        (gethash ',name (package-table *package* t))
        ',body)
       ;; Return the name of the test
       ',name))
  
  ;;; Assert macros
  
  (defmacro assert-eq (expected form &rest extras)
    "Assert whether expected and form are EQ."
  