anchor.diff:                                                    "~%~19t"
                                                     #'(lambda (lib-result)
                                                         (format out
  -                                                              "(:libname ~s :status ~s :test-duration ~s :log-byte-length ~s :log-blob-key ~s)"
  +                                                              "(:libname ~s :status ~a :test-duration ~s :log-byte-length ~s :log-blob-key ~s)"
                                                                 (getf lib-result :libname)
  -                                                              (getf lib-result :status)
  +                                                              (print-test-status nil (getf lib-result :status))
                                                                 (getf lib-result :test-duration)
                                                                 (getf lib-result :log-byte-length)
                                                                 (getf lib-result :log-blob-key))))
  
positive.code: (defun add-run (run-info &optional (db *db*))
    (push run-info (getf db :runs)))
  
  (defun print-list-elements (write-to list separator elem-printer)
    (let ((maybe-separator ""))
      (dolist (elem list)
        (format write-to maybe-separator)
        (funcall elem-printer elem)
        (setf maybe-separator separator))))
  
  (defun save-db (&optional (db *db*) (stream-or-path *standard-db-file*))
    (with-open-file (out stream-or-path
  
negative.code:     (setf all-failures (union non-compiled-failures
                                (rt-api:failed-tests)))
  
      (list :failed-tests (mapcar #'string-downcase all-failures)
            :known-to-fail (mapcar #'string-downcase (rt-api:known-to-fail)))))
  
  (defmethod libtest ((library-name (eql :alexandria)))
  
  