anchor.diff:  	(setf r
   	      (flet ((%do
   		      ()
  -		      (if *compile-tests*
  -			  (multiple-value-list
  -			   (funcall (compile
  -				     nil
  -				     `(lambda ()
  -					(declare
  -					 (optimize ,@*optimization-settings*))
  -					,(form entry)))))
  +		      (cond
  +		       (*compile-tests*
   			(multiple-value-list
  -			 (eval (form entry))))))
  +			 (funcall (compile
  +				   nil
  +				   `(lambda ()
  +				      (declare
  +				       (optimize ,@*optimization-settings*))
  +				      ,(form entry))))))
  +		       (*expanded-eval*
  +			(multiple-value-list
  +			 (expanded-eval (form entry))))
  +		       (t
  +			(multiple-value-list
  +			 (eval (form entry)))))))
   		(if *catch-errors*
   		    (handler-bind
  -			((style-warning #'muffle-warning)
  -			 (error #'(lambda (c)
  -				    (setf aborted t)
  -				    (setf r (list c))
  -				    (return-from aborted nil))))
  -		      (%do))
  +		     (#-ecl (style-warning #'muffle-warning)
  +			    (error #'(lambda (c)
  +				       (setf aborted t)
  +				       (setf r (list c))
  +				       (return-from aborted nil))))
  +		     (%do))
   		  (%do)))))
   
         (setf (pend entry)
   	    (or aborted
   		(not (equalp-with-case r (vals entry)))))
         
  -      (when (and (pend entry) *print-failed-test-cases*)
  +      (when (pend entry)
   	(let ((*print-circle* *print-circle-on-failure*))
   	  (format s "~&Test ~:@(~S~) failed~
                      ~%Form: ~S~
  
positive.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 (cdr *entries*)
  		 :key #'pend)
  	  (length (cdr *entries*)))
    (dolist (entry (cdr *entries*))
      (when (pend entry)
        (format s "~@[~<~%~:; ~:@(~S~)~>~]"
  	      (do-entry entry s))))
    (let ((pending (pending-tests))
  	(expected-table (make-hash-table :test #'equal)))
      (dolist (ex *expected-failures*)
  
negative.code: 		  *test* (form entry)
  		  (length (vals entry))
  		  (vals entry))
  	  (handler-case
  	   (let ((st (format nil "Actual value~P: ~
                        ~{~S~^~%~15t~}.~%"
  			    (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*
  