anchor.diff:  						     (- whitespace-quantity 1)
   						     :always-add-whitespace always-add-whitespace)))))
   
  -; starts-with-whitespace-p: string -> bool
  -; purpose: produces T if the input string starts with a space, otherwise produces NIL
   (defun starts-with-whitespace-p (input-text)
  +  "starts-with-whitespace-p: string -> bool
  +purpose: produces T if the input string starts with a space, otherwise produces NIL"
     (cond
       ((eql (length input-text) 0) NIL)
       ((char= (elt input-text 0) #\Space) T)
       (T NIL)))
   
  -; plist-contains-p: plist any -> bool
  -; purpose: produces T if the input plist contains a key matching the second parameter, otherwise produces NIL
   (defun plist-contains-p (input-plist desired-key)
  +  "plist-contains-p: plist any -> bool
  +purpose: produces T if the input plist contains a key matching the second parameter, otherwise produces NIL."
     (loop for plist-key in input-plist by #'cddr do (when (eql plist-key desired-key) (return-from plist-contains-p T)))
     NIL)
   
  -; next-report-index: -> nat
  -; purpose: produces the next unusued test number and increments the global counter.
   (defvar *report-test-index* 0)
   (defun next-test-index ()
  +  "next-report-index: -> nat
  +purpose: produces the next unusued test number and increments the global counter."
     (setf *report-test-index* (+ 1 *report-test-index*))
     *report-test-index*)
   
  -; print-test-plan: -> string
  -; purpose: prints and returns the test plan string in the TAP format.
   (defun print-test-plan ()
  +  "print-test-plan: -> string
  +purpose: prints and returns the test plan string in the TAP format."
     (let ((result (get-test-plan)))
       (format T result)
       result))
   
  -; get-test-plan: -> string
  -; purpose: returns the test plan string in the TAP format.
   (defun get-test-plan ()
  +  "get-test-plan: -> string
  +purpose: returns the test plan string in the TAP format."
     (format NIL "1..~a" *report-test-index*))
  
positive.code: ; compare-fun: For comparison tests, the function object that was used.
  ; raw-test: The form that was evaluated to produce this test.
  
  ; print-test-list: (listof structured-test) symbol -> string
  ; purpose: prints and returns a test report from the list of tests passed in, using
  ; structured-test-list->tap.
  (defun print-test-list (test-result-list &optional (print-test-plan 'after))
    (let ((result-string (structured-test-list->tap test-result-list print-test-plan)))
      (format T "~a" result-string)
      result-string))
  
  ; structured-test-list->tap: (listof structured-test) symbol -> string
  ; purpose: produces a test report from the list of tests passed in. The report is in the TAP
  ; (Test Anything Protocol) format.
  ; print-test-plan is whether to print the test plan (1..n), and if so when to print it:
  ; NIL: don't print any test plan
  ; 'before: print the test plan before printing a list of tests
  ; 'after: print the test plan after printing a list of test
  (defun structured-test-list->tap (test-result-list &optional (print-test-plan NIL))
    (format NIL "~a~%~{~&~a~}~%~a"
      (if (eql print-test-plan 'before) (format NIL "1..~a" (length test-result-list)) "")
      (loop for test-result in test-result-list 
  	  collecting (structured-test->tap test-result))
      (if (eql print-test-plan 'after) (format NIL "1..~a" (length test-result-list)) "")))
  
  ; structured-test->tap: structured-test -> string
  ; prupose: produces a string containing a part of a report on the test passed in, in the
  ; TAP (Test Anything Protocol) format.
  (defun structured-test->tap (test-result)
    (let ((diagnostic-text (get-diagnostic-text test-result)))
      (format NIL "~:[not ok~;ok~] ~a~a~a~a~a"
        (getf test-result :test-passed)
  
negative.code:       (if (not (equalp diagnostic-text ""))
  	  (format NIL "~%~a" (start-all-lines-with-whitespace diagnostic-text :always-add-whitespace T)) ""))))
  
  (defun get-diagnostic-text (test-result)
    "get-diagnostic-text: structured-test -> string
  purpose: produces a string containing the diagnostic text, in the TAP format, for the test that is passed in."
    (format NIL "~{~a~^~&~}"
      (remove NIL (list
        (if (plist-contains-p test-result :test-value)
  