anchor.diff:      (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
  
positive.code:       (%run-all-thunks package)
        (%run-thunks test-names package)))
  
  (defun run-tags (tags &optional (package *package*))
    "Run the tests associated with the specified tags in package."
    (%run-thunks (tagged-tests tags package) package))
  
  (defun set-equal (l1 l2 &key (test #'equal))
    "Return true if every element of l1 is an element of l2 and vice versa."
    (and (listp l1)
  
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)))
  
  