The simplest way to get rid of the repeated similar calls to **FORMAT** is to create a new function.

Now you can write test-+ with calls to report-result instead of **FORMAT**. It’s not a huge improvement, but at least now if you decide to change the way you report results, there’s only one place you have to change.

(defun test-+ ()
  (report-result (= (+ 1 2) 3) '(= (+ 1 2) 3))
  (report-result (= (+ 1 2 3) 6) '(= (+ 1 2 3) 6))
  (report-result (= (+ -1 -3) -4) '(= (+ -1 -3) -4)))

Next you need to get rid of the duplication of the test case expression, with its attendant risk of mislabeling of results. What you’d really like is to be able to treat the expression as both code (to get the result) and data (to use as the label). Whenever you want to treat code as data, that’s a sure sign you need a macro. Or, to look at it another way, what you need is a way to automate writing the error-prone report-result calls. You’d like to be able to say something like this:

(check (= (+ 1 2) 3))

Writing a macro to do this translation is trivial.

(defmacro check (form)

Now you can change test-+ to use check.

(defun test-+ ()
  (check (= (+ 1 2) 3))
  (check (= (+ 1 2 3) 6))
  (check (= (+ -1 -3) -4)))

Since you’re on the hunt for duplication, why not get rid of those repeated calls to check? You can define check to take an arbitrary number of forms and wrap them each in a call to report-result.

With the new version of check you can write a new version of test-+ like this:

  (check
    (= (+ 1 2 3) 6)
    (= (+ -1 -3) -4)))

that is equivalent to the following code:

(defun test-+ ()
  (progn
    (report-result (= (+ 1 2) 3) '(= (+ 1 2) 3))
    (report-result (= (+ 1 2 3) 6) '(= (+ 1 2 3) 6))

Thanks to check, this version is as concise as the first version of test-+ but expands into code that does the same thing as the second version. And now any changes you want to make to how test-+ behaves, you can make by changing check.