anchor.diff:    (if (eq :all names)
         (if (null package)
             (clrhash *test-db*)
  -          (progn
  -            (remhash (find-package package) *test-db*)
  -            (remhash (find-package package) *tag-db*)))
  +          (remhash (find-package package) *test-db*))
         (let ((table (package-table package)))
           (unless (null table)
             ;; Remove tests
             (loop for name in names
                   always (remhash name table)
                   collect name into removed
  -                finally (return removed))
  -          ;; Remove tests from tags
  -          (loop with tags = (package-tags package)
  -                for tag being each hash-key in tags
  -                using (hash-value tagged-tests)
  -                do
  -                (setf
  -                 (gethash tag tags)
  -                 (set-difference tagged-tests names)))))))
  -
  -;;; Manage tags
  -
  -(defun %tests-from-all-tags (&optional (package *package*))
  -  "Return all of the tests that have been tagged."
  -  (loop for tests being each hash-value in (package-tags package)
  -        nconc (copy-list tests) into all-tests
  -        finally (return (delete-duplicates all-tests))))
  -
  -(defun %tests-from-tags (tags &optional (package *package*))
  -  "Return the tests associated with the tags."
  -  (loop with table = (package-tags package)
  -        for tag in tags
  -        as tests = (gethash tag table)
  -        nconc (copy-list tests) into all-tests
  -        finally (return (delete-duplicates all-tests))))
  -
  -(defun list-tags (&optional (package *package*))
  -  "Return a list of the tags in package."
  -  (let ((tags (package-tags package)))
  -    (when tags
  -      (loop for tag being each hash-key in tags collect tag))))
  -
  -(defun tagged-tests (tags &optional (package *package*))
  -  "Run the tests associated with the specified tags in package."
  -  (if (eq :all tags)
  -      (%tests-from-all-tags package)
  -      (%tests-from-tags tags package)))
  -
  -(defun remove-tags (tags &optional (package *package*))
  -  "Remove individual tags or entire sets."
  -  (if (eq :all tags)
  -      (if (null package)
  -          (clrhash *tag-db*)
  -          (remhash (find-package package) *tag-db*))
  -      (let ((table (package-tags package)))
  -        (unless (null table)
  -          (loop for tag in tags
  -                always (remhash tag table)
  -                collect tag into removed
                   finally (return removed))))))
   
   ;;; Assert macros
  
positive.code:     (setf (gethash package *test-db*) (make-hash-table)))
     (t (warn "No tests defined for package: ~S" package))))
  
  ;;; Global tags database
  
  (defparameter *tag-db* (make-hash-table :test #'eq)
    "The tag database is simply a hash table.")
  
  (defun package-tags (package &optional create)
    "Return the tags DB for the package."
    (cond
     ((gethash (find-package package) *tag-db*))
     (create
      (setf (gethash package *tag-db*) (make-hash-table)))
     (t (warn "No tags defined for package: ~S" package))))
  
  (defclass unit-test ()
    ((doc
      :type string
  
negative.code:    "Organize the unit test documentation and code."))
  
  ;;; NOTE: Shamelessly taken from PG's analyze-body
  (defun parse-body (body &optional doc)
    "Separate the components of the body."
    (let ((item (first body)))
      (if (and (stringp item) (not doc) (rest body))
          (parse-body (rest body) doc)
          (values doc body))))
  
  (defmacro define-test (name &body body)
    "Store the test in the test database."
    (multiple-value-bind (doc code) (parse-body body)
      `(let ((doc (or ,doc (string ',name))))
         (setf
          ;; Unit test
          (gethash ',name (package-table *package* t))
          (make-instance 'unit-test :doc doc :code ',code))
         ;; Return the name of the test
         ',name)))
  
  