anchor.diff:  (in-suite std-allocate-sheep)
   
   (test (std-sheep-basic-structure :fixture with-std-sheep)
  -  (is (vectorp sheep))
  -  (is (= 6 (length sheep))))
  -
  -(test (std-sheep-initial-values :depends-on std-sheep-basic-structure)
  +  (is (typep sheep 'structure-object))
  +  (is (typep sheep 'sheep)))
  +
  +(test std-sheep-initial-values
     (let ((sheep (std-allocate-sheep =standard-metasheep=)))
  -    (is (eql =standard-metasheep= (svref sheep 0)))
  -    (is (null (svref sheep 1)))
  -    (is (null (svref sheep 2)))
  -    (is (null (svref sheep 3)))
  -    (is (null (svref sheep 4)))
  -    (is (null (svref sheep 5)))))
  +    (is (eq =standard-metasheep= (%sheep-metasheep sheep)))
  +    (is (eq nil (%sheep-parents sheep)))
  +    (is (eq nil (%sheep-properties sheep)))
  +    (is (eq nil (%sheep-roles sheep)))
  +    (is (eq nil (%sheep-hierarchy-cache sheep)))
  +    (is (eq nil (%sheep-children sheep)))))
   
   (test allocate-sheep
     (let ((sheep (allocate-sheep =standard-metasheep=)))
  -    (is (vectorp sheep))
  -    (is (= 6 (length sheep)))
  -    (is (eql =standard-metasheep= (svref sheep 0)))
  -    (is (null (svref sheep 1)))
  -    (is (null (svref sheep 2)))
  -    (is (null (svref sheep 3)))
  -    (is (null (svref sheep 4)))
  -    (is (null (svref sheep 5)))))
  +    (is (eq =standard-metasheep= (%sheep-metasheep sheep)))
  +    (is (eq nil (%sheep-parents sheep)))
  +    (is (eq nil (%sheep-properties sheep)))
  +    (is (eq nil (%sheep-roles sheep)))
  +    (is (eq nil (%sheep-hierarchy-cache sheep)))
  +    (is (eq nil (%sheep-children sheep)))))
   
   (in-suite allocation)
   
   (test std-sheep-p
  -  (for-all ((sheep (gen-vector :length (constantly 6))))
  -    (setf (elt sheep 0) =standard-metasheep=)
  -    (is (std-sheep-p sheep)))
  -  (for-all ((dummy (gen-vector)))
  -    (is (not (std-sheep-p dummy))))
  -  (for-all ((dummy (gen-vector)
  -                   (and (/= 6 (length dummy))
  -                        (not (zerop (length dummy))))))
  -    (setf (elt dummy 0) =standard-metasheep=)
  -    (is (not (std-sheep-p dummy)))))
  +  (for-all ((sheep (fun (std-allocate-sheep (funcall (gen-integer))))))
  +    (is (not (std-sheep-p sheep))))
  +  (for-all ((sheep (fun (std-allocate-sheep =standard-metasheep=))))
  +    (is (std-sheep-p sheep))))
   
   (test (sheepp :fixture (allocate-sheep =standard-metasheep=))
     (is (sheepp sheep)))
  
positive.code:     (is (null (find child (%sheep-children sheep) :key #'maybe-weak-pointer-value)))))
  
  (test %map-children
    (let ((parent (cons-std-sheep))
          (child1 (cons-std-sheep))
          (child2 (cons-std-sheep))
          (child3 (cons-std-sheep)))
      (%add-child child1 parent)
      (%add-child child2 parent)
      (%add-child child3 parent)
      (%map-children (fun (setf (elt _ 0) nil)) parent)
      (is (null (elt child1 0)))
      (is (null (elt child2 0)))
      (is (null (elt child3 0)))))
  
  (test memoize-sheep-hierarchy-list
    (let ((sheep1 (cons-std-sheep))
  
negative.code: 
  (def-suite early-printing :in sheep-objects)
  (in-suite early-printing)
  
  ;;; This test is pretty crude. The correct thing to do would be to
  ;;; parse the output, extract the implementation-dependant stuff,
  