anchor.diff:  
   ;;;; Request / Connection testing
   
  +;;; Output, sending requests
   
   (defvar *test-sink-stream*)
   (defvar *test-response-desc*)
  -(defvar *test-out-desc*)
  +;;(defvar *test-out-desc*)                ; unused?
   (defvar *test-out-conn* nil)
  +
  +;;; Input, receiving requests
  +
  +(defvar *test-in-conn*)
  +(defvar *test-response-sink*)
  +(defvar *test-request-desc*)
  +
  +
  +;;; Mock classes
   
   (defclass test-connection (connection)
     ((response-func :initarg response-func 
  
positive.code:     (marshal-giop-set-message-length buffer)
      (let ((octets (buffer-octets buffer)))
        (io-descriptor-set-write *test-response-desc* octets 0 (length octets)))))
  
negative.code:       (funcall fun req))))
  
  
  ;;; Setup code
  
  (defun make-test-connection ()
    (let ((desc (make-io-descriptor))
          (i-stream (make-octet-stream "i-stream"))
          (o-stream (make-octet-stream "o-stream")))
      (let ((other (make-io-descriptor
                    :stream (make-shortcut-stream (make-octet-stream "dummy") i-stream)
                    :status :connected
                    :shortcut-p desc)))
        (setf (io-descriptor-stream desc) (make-shortcut-stream i-stream o-stream))
        (setf (io-descriptor-shortcut-p desc) other)
        (let ((conn (make-instance 'test-connection
                      :orb (CORBA:ORB_init)
                      :io-descriptor desc)))
          (io-descriptor-associate-connection desc conn)
          (values conn other o-stream)))))
  
  
  (defun setup-test-out ()
    (multiple-value-setq (*test-out-conn* *test-response-desc* *test-sink-stream*)
      (make-test-connection)))
  
  
  (defun setup-test-in ()
    (multiple-value-setq (*test-in-conn* *test-request-desc* *test-response-sink*)
      (make-test-connection))
    (setup-incoming-connection *test-in-conn*))
          
  
  
  
  
  ;;; Testing functions
  
  (defun test-object (orb)
    "Create a proxy object connected to the testing output connection.
  Requests sent to this object will end up in *test-sink-stream*."
    (let ((obj (make-instance 'CORBA:Proxy
                 :id "IDL:test:1.0"
                 :the-orb orb
  