anchor.diff:    (is (has-d (optional-import-message m)))
     (is (= (d (optional-import-message m)) 120))
   
  -  ;; repeated fields
  -  (let ((field-info *repeated-field-info*))
  -    (loop for (field . values) in field-info do
  -      (let ((accessor (field-function "" field))
  -            (v0 (first values))
  -            (v1 (second values)))
  -        (is (= (length (funcall accessor m)) 2))
  -        (field-equal (aref (funcall accessor m) 0) v0)
  -        (field-equal (aref (funcall accessor m) 1) v1))))
  +  (expect-repeated-fields-set m *repeated-field-info*)
     (let ((v (repeated-group m)))
       (is (= (length v) 2))
       (is (= (a (aref v 0)) 217))
  
positive.code:     (packed-bool t nil)
      (packed-enum ,+foreign-enum-foreign-bar+ ,+foreign-enum-foreign-baz+)))
  
  (defun expect-packed-fields-set (m)
    (loop for (field . values) in *packed-field-info* do
      (let ((accessor (field-function "" field))
            (v0 (first values))
            (v1 (second values)))
        (is (= (length (funcall accessor m)) 2))
        (field-equal (aref (funcall accessor m) 0) v0)
        (field-equal (aref (funcall accessor m) 1) v1))))
  
  (defun read-message (class-name file-name)
    (let ((message (make-instance class-name)))
      (with-open-file (input file-name :direction :input :element-type 'unsigned-byte)
        (let* ((size (file-length input))
               (buffer (make-array size :element-type '(unsigned-byte 8))))
          (read-sequence buffer input)
          (pb:merge-from-array message buffer 0 size)))
      message))
  
  (deftest test-parse-from-file ()
    (let ((message (read-message 'test-all-types +golden-file-name+)))
      (expect-all-fields-set message)))
  
  (deftest test-parse-packed-from-file ()
    (let ((message (read-message 'test-packed-types +golden-packed-file-name+)))
      (expect-packed-fields-set message)))
  
  (defun set-all-fields (m)
    ;; optional and default fields
  
negative.code:   (let ((package (find-package 'protobuf-unittest)))
      (fdefinition `(setf ,(find-symbol (symbol-name field) package)))))
  
  (defun set-repeated-fields (m field-info)
    (loop for (field . values) in field-info do
      (let ((accessor (field-function "" field))
            (v0 (first values))
            (v1 (second values)))
        (vector-push-extend v0 (funcall accessor m))
        (vector-push-extend v1 (funcall accessor m)))))
  
  (defun expect-repeated-fields-set (m field-info)
    (loop for (field . values) in field-info do
      (let ((accessor (field-function "" field))
            (v0 (first values))
            (v1 (second values)))
        (is (= (length (funcall accessor m)) 2))
        (field-equal (aref (funcall accessor m) 0) v0)
        (field-equal (aref (funcall accessor m) 1) v1))))
  
  (defun expect-all-fields-set (m)
    ;; optional and default fields
    (let ((field-info (append *optional-field-info* *default-field-info*)))
  