Now that you have two test functions, you’ll probably want another function that runs all the tests. That’s easy enough.

    1. (defun test-arithmetic ()
    2.   (combine-results
    3.    (test-+)
    4.    (test-*)))

    In this function you use combine-results instead of check since both test-+ and test-* will take care of reporting their own results. When you run test-arithmetic, you’ll get the following results:

    Since the code that prints the results is centralized in report-result, you need a way to pass information about what test function you’re in to report-result. You could add a parameter to to pass this information, but check, which generates the calls to report-result, doesn’t know what function it’s being called from, which means you’d also have to change the way you call check, passing it an argument that it simply passes onto report-result.

    This is exactly the kind of problem dynamic variables were designed to solve. If you create a dynamic variable that each test function binds to the name of the function before calling check, then report-result can use it without check having to know anything about it.

    1. (defvar *test-name* nil)

    Now you need to make another tiny change to report-result to include *test-name* in the **FORMAT** output.

    With those changes, the test functions will still work but will produce the following output because *test-name* is never rebound:

    1. pass ... NIL: (= (+ 1 2) 3)
    2. pass ... NIL: (= (+ 1 2 3) 6)
    3. pass ... NIL: (= (+ -1 -3) -4)
    4. pass ... NIL: (= (* 2 2) 4)
    5. pass ... NIL: (= (* 3 5) 15)

    Now the results are properly labeled.

    1. CL-USER> (test-arithmetic)
    2. pass ... TEST-+: (= (+ 1 2) 3)
    3. pass ... TEST-+: (= (+ 1 2 3) 6)
    4. pass ... TEST-+: (= (+ -1 -3) -4)
    5. pass ... TEST-*: (= (* 2 2) 4)