anchor.diff:  
   (defun test-case (test-case-name tests)
     (labels
  -    ((test-case-inner (tests tests-passed tests-failed)
  +    ((get-test-name () (cadar tests))
  +     (get-asserts () (caddar tests))
  +     (test-case-inner (tests tests-passed tests-failed)
          (cond ((null tests)
                 (format t "(~a) ~d tests run: ~d passed, ~d failed~%"
                         test-case-name (+ tests-passed tests-failed)
                         tests-passed tests-failed))
  -             (t (let* ((test-name (cadar tests))
  -                       (asserts (caddar tests))
  +             (t (let* ((test-name (get-test-name))
  +                       (asserts (get-asserts))
                          (test-passedp (test test-case-name test-name asserts))
                          (tests-passed (+ tests-passed (if test-passedp 1 0)))
                          (tests-failed (+ tests-failed
  
positive.code: 
  (defun assert-equal (test-case-name test-name param1 param2)
    (let ((passedp (equal param1 param2)))
      (not (if (not passedp) (format t "(~a) ~a: ~a != ~a~%"
                                     test-case-name test-name param1 param2)))))
  
negative.code: 
  (defun test (test-case-name test-name asserts)
    (labels
      ((get-assert () (caar asserts))
       (get-argument1 () (cadar asserts))
       (get-argument2 () (caddar asserts))
       (test-inner (asserts passedp)
         (cond ((null asserts) passedp)
               (t (let* ((assert (get-assertf (get-assert)))
                         (argument1 (eval (get-argument1)))
                         (argument2 (eval (get-argument2)))
                         (assert-passedp (assert test-case-name test-name
                                                 argument1 argument2))
                         (passedp (and passedp assert-passedp)))
  