anchor.diff:  		  *test* (form entry)
   		  (length (vals entry))
   		  (vals entry))
  -	  (format s "Actual value~P: ~
  +	  (handler-case
  +	   (let ((st (format nil "Actual value~P: ~
                         ~{~S~^~%~15t~}.~%"
  -		  (length r) r)))))
  +			    (length r) r)))
  +	     (format s "~A" st))
  +	   (error () (format s "Actual value: #<error during printing>~%")
  +		  ))
  +	  (finish-output s)
  +	  ))))
     (when (not (pend entry)) *test*))
  +
  +(defun expanded-eval (form)
  +  "Split off top level of a form and eval separately.  This reduces the chance that
  +   compiler optimizations will fold away runtime computation."
  +  (if (not (consp form))
  +      (eval form)
  +   (let ((op (car form)))
  +     (cond
  +      ((eq op 'let)
  +       (let* ((bindings (loop for b in (cadr form)
  +			      collect (if (consp b) b (list b nil))))
  +	      (vars (mapcar #'car bindings))
  +	      (binding-forms (mapcar #'cadr bindings)))
  +	 (apply
  +	  (the function
  +	    (eval `(lambda ,vars ,@(cddr form))))
  +	  (mapcar #'eval binding-forms))))
  +      ((and (eq op 'let*) (cadr form))
  +       (let* ((bindings (loop for b in (cadr form)
  +			      collect (if (consp b) b (list b nil))))
  +	      (vars (mapcar #'car bindings))
  +	      (binding-forms (mapcar #'cadr bindings)))
  +	 (funcall
  +	  (the function
  +	    (eval `(lambda (,(car vars) &aux ,@(cdr bindings)) ,@(cddr form))))
  +	  (eval (car binding-forms)))))
  +      ((eq op 'progn)
  +       (loop for e on (cdr form)
  +	     do (if (null (cdr e)) (return (eval (car e)))
  +		  (eval (car e)))))
  +      ((and (symbolp op) (fboundp op)
  +	    (not (macro-function op))
  +	    (not (special-operator-p op)))
  +       (apply (symbol-function op)
  +	      (mapcar #'eval (cdr form))))
  +      (t (eval form))))))
   
   (defun continue-testing ()
     (if *in-test*
  
positive.code: 	 (apply #'format t args)
  	 (if error? (throw '*debug* nil)))
  	(error? (apply #'error args))
  	(t (apply #'warn args))))
  
  (defun do-test (&optional (name *test*))
    (do-entry (get-entry name)))
  
  (defun equalp-with-case (x y)
    "Like EQUALP, but doesn't do case conversion of characters."
    (cond
     ((eq x y) t)
     ((consp x)
  
negative.code: 	  (stream out :direction :output)
  	(do-entries stream))))
  
  (defun do-entries* (s)
    (format s "~&Doing ~A pending test~:P ~
               of ~A tests total.~%"
            (count t (the list (cdr *entries*)) :key #'pend)
  	  (length (cdr *entries*)))
    (finish-output s)
    (dolist (entry (cdr *entries*))
      (when (and (pend entry)
  	       (not (has-disabled-note entry)))
        (format s "~@[~<~%~:; ~:@(~S~)~>~]"
  	      (do-entry entry s))
        (finish-output s)
        ))
    (let ((pending (pending-tests))
  	(expected-table (make-hash-table :test #'equal)))
      (dolist (ex *expected-failures*)
  