anchor.diff:  (defun remove-tests (names &optional (package *package*))
     (let ((table (get-package-table package)))
       (unless (null table)
  -      (if (null names)
  +      (if (eq :all names)
             (clrhash table)
  -          (dolist (name names)
  -            (remhash name table))))))
  +          (loop for name in names always
  +                (remhash name table))))))
   
   (defun remove-all-tests (&optional (package *package*))
     (if (null package)
  
positive.code:                     ,test))
  
  (defmacro expand-error-form (form)
    `(handler-case ,form
       (condition (error) error)))
  
  (defmacro expand-output-form (form)
    (let ((out (gensym)))
      `(let* ((,out (make-string-output-stream))
              (*standard-output* (make-broadcast-stream *standard-output* ,out)))
         ,form
         (get-output-stream-string ,out))))
  
  (defmacro expand-macro-form (form env)
    `(macroexpand-1 ',form ,env))
  
  (defmacro expand-extras (extras)
    `(lambda () (list ,@(mapcan (lambda (form) (list `',form form)) extras))))
  
  ;;; RUN-TESTS
  
  (defmacro run-all-tests (package &rest tests)
    `(let ((*package* (find-package ',package)))
       (run-tests
        ,@(mapcar (lambda (test) (find-symbol (symbol-name test) package))
                  tests))))
  
  (defmacro run-tests (&rest names)
    `(run-test-thunks
      (get-test-thunks ,(if (null names) '(get-tests *package*) `',names))))
  
  (defun get-test-thunks (names &optional (package *package*))
    (mapcar (lambda (name) (get-test-thunk name package))
            names))
  
  (defun get-test-thunk (name package)
    (assert (get-test-code name package) (name package)
  
negative.code:   (:use :common-lisp)
    ;; Functions for managing tests
    (:export
     :define-test
     :get-tests :get-test-code
     :remove-tests :remove-all-tests
     :run-tests :run-all-tests
     :use-debugger
     :with-test-listener)
    ;; Forms for assertions
  