Fixing the Return Value

You can start with fixing test-+ so its return value indicates whether all the test cases passed. Since check is responsible for generating the code that ultimately runs the test cases, you just need to change it to generate code that also keeps track of the results.

As a first step, you can make a small change to report-result so it returns the result of the test case it’s reporting.

  1. (defun report-result (result form)
  2.   (format t "~:[FAIL~;pass~] ... ~a~%" result form)
  3.   result)

Now that report-result returns the result of its test case, it might seem you could just change the **PROGN** to an **AND** to combine the results. Unfortunately, **AND** doesn’t do quite what you want in this case because of its short-circuiting behavior: as soon as one test case fails, **AND** will skip the rest. On the other hand, if you had a construct that worked like **AND** without the short-circuiting, you could use it in the place of **PROGN**, and you’d be done. Common Lisp doesn’t provide such a construct, but that’s no reason you can’t use it: it’s a trivial matter to write a macro to provide it yourself.

Leaving test cases aside for a moment, what you want is a macro—let’s call it combine-results--that will let you say this:

  1. (combine-results
  2.   (foo)
  3.   (bar)
  4.   (baz))

and have it mean something like this:

  1. (let ((result t))
  2.   (unless (foo) (setf result nil))
  3.   (unless (bar) (setf result nil))
  4.   (unless (baz) (setf result nil))
  5.   result)

The only tricky bit to writing this macro is that you need to introduce a variable—result in the previous code—in the expansion. As you saw in the previous chapter, using a literal name for variables in macro expansions can introduce a leak in your macro abstraction, so you’ll need to create a unique name. This is a job for with-gensyms. You can define combine-results like this:

  1. (defmacro combine-results (&body forms)
  2.   (with-gensyms (result)
  3.     `(let ((,result t))
  4.       ,@(loop for f in forms collect `(unless ,f (setf ,result nil)))
  5.       ,result)))

Now you can fix check by simply changing the expansion to use combine-results instead of **PROGN**.

  1. (defmacro check (&body forms)
  2.   `(combine-results
  3.     ,@(loop for f in forms collect `(report-result ,f ',f))))

With that version of check, test-+ should emit the results of its three test expressions and then return **T** to indicate that everything passed.4

  1. CL-USER> (test-+)
  2. pass ... (= (+ 1 2) 3)
  3. pass ... (= (+ 1 2 3) 6)
  4. pass ... (= (+ -1 -3) -4)
  5. T

And if you change one of the test cases so it fails,5 the final return value changes to **NIL**.

  1. CL-USER> (test-+)
  2. pass ... (= (+ 1 2) 3)
  3. pass ... (= (+ 1 2 3) 6)
  4. FAIL ... (= (+ -1 -3) -5)
  5. NIL