The cacau Reference Manual

1 Introduction
2 Systems
- 2.1 cacau
3 Modules
4 Files
- 4.1 Lisp
5 Packages
- 5.1 noloop.cacau
6 Definitions
- 6.1 Exported definitions
- 6.2 Internal definitions
Appendix A Indexes

The cacau Reference Manual

This is the cacau Reference Manual, version 1.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 03:26:48 2022 GMT+0.

1 Introduction

cacau

Read in other languages

Read this in other languages: English, Portuguese-br

Quickstart

(defpackage #:cacau-examples-quickstart
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-quickstart)

(deftest "Test-1" () (eql-p 1 1))
(deftest "Test-2" () (eql-p 2 2))
(deftest "Test-3" () (eql-p 3 3))

(run :colorful t)

And you get the output of the reporter :min that is the default of the cacacau:

cacau quickstart output by :min reporter

There are also others reporters.

See that the cacau returned T, this happened because none test failed, when there are tests failing or errors (errors of hooks by example) it's returned NIL.

Getting Started in cacau

Summary

cacau

Portability

I just tested on Linux using SBCL, coming soon I will writer tests for the others platforms using some CI tool.

Dependencies

:eventbus :assertion-error

Download and Load

1 - Load cacau system by quicklisp

IN PROGRESS...

2 - Download and load cacau system by github and asdf

download from github:

git clone https://github.com/noloop/cacau.git

and load by asdf:

(asdf:load-system :cacau)

Note: Remember to configure asdf to find your directory where you downloaded the libraries (asdf call them "systems") above, if you do not know how to make a read at:

https://common-lisp.net/project/asdf/asdf/Configuring-ASDF-to-find-your-systems.html

https://lisp-lang.org/learn/writing-libraries

Assertions

The cacau was built to be independent of assertions systems, is true that in Common Lisp we don't have many systems of assertions, but I'm trying with the cacau create this pattern so it can make it easier to use of one some assertion system in many different test runner systems. So the user stay free to choice what more please you. I built the assertion system :assert-p, and in the example quickstart I use both systems together to create the tests.

Is simple, there is the :cacau test runner system and the :assert-p assertion system, when there is one assertion fail is throw one :assertion-error that is caught and stored by :cacau it to give the end result of the tests race.

With this is easier emerge new assertions systems for specific cases or aiming different syntax, which the :cacau can works with them.

Functionalities

Suites

You can organize your tests in suites:

(defpackage #:cacau-examples-suites
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-suites)

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" () (t-p t)))

(defsuite :suite-2 ()
  (let ((x 0))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" () (t-p t))
    (defsuite :suite-3 ()
      (deftest "Test-1" () (t-p t))
      (deftest "Test-2" () (t-p t)))))

(run)

The cacau test runner it has one :suite-root, so always that you call the function (run) a new runner is created with one new :suite-root.

Hooks

The order of execution of the hooks follow the topics order below, thus is executed:

before-all hook
before-each hook
after-each hook
after-all hook

before all

Do something before all tests of one suite.

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defsuite :suite-with-before-all ()
  (let ((x 0))
    (defbefore-all "Before-all" () (setf x 1))
    (deftest "Test-1" () (eql-p x 1))
    (deftest "Test-2" () (eql-p x 1))))
    
(run)

before each

Do something before each test of one suite.

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defsuite :suite-with-before-each ()
  (let ((x 0))
    (defbefore-each "Before-each" () (setf x 1))
    (deftest "Test-1" () (eql-p x 1))
    (deftest "Test-2" () (eql-p x 1))))
    
(run)

after each

Do something after each test of one suite.

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defsuite :suite-with-after-each ()
  (let ((x 0))
    (defafter-each "After-each" () (setf x 1))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" () (eql-p x 1))))
    
(run)

after all

Do something after all tests of one suite.

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defsuite :suite-with-after-all ()
  (let ((x 0))
    (defafter-all "After-all" () (setf x 1))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" () (eql-p x 0))))
    
(run)

hooks in :suite-root

For use hooks in :suite-root it's as simple as call the hooks functions without be inside of some suite:

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defbefore-all "Before-all" () (print ":suite-root's before-all"))
(defbefore-each "Before-each" () (print ":suite-root's before-each"))
(defafter-each "After-each" () (print ":suite-root's after-each"))
(defafter-all "After-all" () (print ":suite-root's after-all"))

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" () (t-p t)))
  
(run)

Before/after each inheritance

The hooks that execute something before or after of one suite are executed only once time, and only at that suite.

However the hooks that execute something before or after each test are inherited, by example, if one dad suite of name :suite-1 has one hook for execute something before each test, and this suite have one daughter suite called :suite-2, that also has one hook for execute something before each test, so, when run the tests of the :suite-1 only the your hook will be executed, but when run the tests of the :suite-2, will be executed the first hook of the dad suite and after the hook of the daughter suite. See one example for better understanding:

(defpackage #:cacau-examples-hooks
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-hooks)

(defsuite :suite-1 ()
  (defbefore-each "Before-each Suite-1" ()
    (print "run Before-each Suite-1"))
  (deftest "Test-1" () (print "run Test-1") (t-p t))
  (defsuite :suite-1 ()
    (defbefore-each "Before-each Suite-2" ()
      (print "run Before-each Suite-2"))
    (deftest "Test-1" () (print "run Test-2") (t-p t))))
    
(run)

This will print:

"run Before-each Suite-1" 
"run Test-1" 
"run Before-each Suite-1" 
"run Before-each Suite-2" 
"run Test-2"

For more understanding see the file of hooks examples.

Be aware that when hooks throw errors with except of the extrapolated timeout error, they are going to abort the tests race and the result will be give. This happens because the cacau think that for the tests be run correctly before should whole your configured hooks be run correctly.

Only and Skip

You can want run some tests in isolation or skip some tests for sometime. With the cacau you can do this, and you can isolate or skip both suites and tests.

run only tests/suites

(defpackage #:cacau-examples-onlys
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-onlys)

(defsuite :suite-1 ()
  (deftest "Test-1" (:only) (t-p t))
  (deftest "Test-2" () (t-p t)))

(defsuite :suite-2 ()
  (let ((x 0))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" () (t-p t))
    (defsuite :suite-3 (:only)
      (deftest "Test-1" () (t-p t))
      (deftest "Test-2" () (t-p t)))))

(run)

With the code above three tests are executed: The "Test-1" of the "Suite-1", and both the tests of the "Suite-3".

skip tests/suites

(defpackage #:cacau-examples-skips
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-skips)

(defsuite :suite-1 ()
  (deftest "Test-1" (:skip) (t-p t))
  (deftest "Test-2" () (t-p t)))

(defsuite :suite-2 (:skip)
  (let ((x 0))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" () (t-p t))
    (defsuite :suite-3 ()
      (deftest "Test-1" () (t-p t))
      (deftest "Test-2" () (t-p t)))))

(run :colorful t)

With the code above just the "Test-2" of the "Suite-1" is executed.

precedence order "skip -> only

The rule is simple:

The tests or suites skip have precedence to tests or suites only. See one example:

(defpackage #:cacau-examples-skips-onlys-rules
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-skips-onlys-rules)

(defsuite :suite-1 (:only)
  (deftest "Test-1" () (t-p t)) ;; run!
  (deftest "Test-2" () (t-p t)) ;; run!
  (defsuite :suite-2 (:skip)
    (deftest "Test-1" () (t-p t))
    (deftest "Test-2" () (t-p t))))
(run :colorful t)

You can want see the file of the examples of skip->only rule for better comprehension.

Timeout

You can define one limit time for your tests, suites and hooks. Read with attention the topics below, because there are differences between the three possibilities.

defining suite timeout

When define one timeout for one suite, this will make with that all tests of that suite acquire the same timeout of that suite.

(defpackage #:cacau-examples-timeout
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-timeout)

(defsuite :suite-1 ((:timeout 0))
  (deftest "Test-1" () (t-p t)) ;; Timeout Error: Time(0) extrapolated!
  (deftest "Test-2" () (t-p t))) ;; Timeout Error: Time(0) extrapolated!
  
(run)

defining hook timeout

When define one timeout for one hook, this limit timeout only will have importance for the hook configured. When there are timeout fail the tests race will not aborted, as happen when hooks fail for throw of any others errors.

(defpackage #:cacau-examples-timeout
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-timeout)

(defsuite :suite-1 ()
  (defbefore-all "Before-all" ((:timeout 0))) ;; Timeout Error: Time(0) extrapolated!
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" () (t-p t)))
          
(run)

defining test timeout

When define one timeout for the one test, this limit time only have importance for the test configured. When there are timeout fail the tests race will not aborted.

(defpackage #:cacau-examples-timeout
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-timeout)

(defsuite :suite-1 ()
  (deftest "Test-1" ((:timeout 0)) (t-p t)) ;; Timeout Error: Time(0) extrapolated!
  (deftest "Test-2" () (t-p t)))

(run)

If the test or suite are inside the some suite that already has configured with one timeout, the same is ignored, and what predominate is the timeout of the test or suite daughter that was configured.

(defpackage #:cacau-examples-timeout
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-timeout)

(defsuite :suite-1 ((:timeout 0))
  (deftest "Test-1" () (t-p t))   ;; Timeout Error: Time(0) extrapolated!
  (deftest "Test-2" () (t-p t))   ;; Timeout Error: Time(0) extrapolated!
  (defsuite :suite-2 ((:timeout 50000))
    (deftest "Test-1" ((:timeout 0)) (t-p t)) ;; Timeout Error: Time(0) extrapolated!
    (deftest "Test-2" () (t-p t))))

(run)

You can want see the file of the examples of timeout for better comprehension.

Test asynchronous code

You may need test some asynchronous code, and the cacau was built in a way to wait each test before the next execution test. You will need call one done function and also tell to cacau which test or hook is asynchronous. See one example of as write one test to test your async code:

(defpackage #:cacau-examples-async-test
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-async-test)

(defsuite :suite-1 ()
  (deftest "Test-1" ((:async done))
    (funcall done))
  (deftest "Test-2" () (t-p t)))
  
  (run)

Above is configured one test passing (:async done) as configurations, where done is the name of the function that you need call for the test be end, you can give to done any name that wish, by example:

(deftest "Test-1" ((:async something))
    (funcall something))

Attention for that if you don't call done or the name that you choice, the cacau going to waits forever by the call. So you will not want forget of call done for end your test.

Can be passed three types of different arguments for the done function, it accept one assertion-error, one error, or one lambda. This is useful for you catch assertion errors. By example, passing one assertion-error:

(defpackage #:cacau-examples-async-test
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-async-test)

(deftest "Test-1" ((:async done))
      (handler-case (t-p nil)
        (error (c)
          (funcall done c))))
          
 (run)

Or passing one function lambda where you can call assertion functions that will be catches by cacau, as in the tests to test synchronous things:

(defpackage #:cacau-examples-async-test
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-async-test)

(deftest "Test-2" ((:async done))
      (funcall done (lambda () (t-p t))))
          
 (run)

You can want see the file of the examples of async test for better comprehension.

Interfaces

The cacau was built in a way support the create new interfaces, so you can use whichever you prefer, or even contribute with the cacau project building one new interface.

You don't need setting nothing or passing nothing when call (run) to use some interface. All interfaces are available for you use whichever you wish, and until mix them, but I don't recommend do this, keep one pattern, and use just one interface for better readability of the code.

cl

This interface was one that was used in the examples above. It works by define suites inside others suites, and provides the macros:

(defsuite name options &body body)
(defbefore-all name options &body body)
(defbefore-each name options &body body)
(defafter-each name options &body body)
(defafter-all name options &body body)
(deftest name options &body body)

The options parameter receive one list that should have zero or more of the following items, in the hooks:

((:async done) (:timeout 0))

in defsuite or deftest:

(:skip :only (:async done) (:timeout 0))

See one example of use:

(defpackage #:cacau-examples-interfaces
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-interfaces)
  
(defsuite :suite-1 ()
  (let ((x 0))
    (defbefore-all "Before-all Suite-1" () (setf x 1))
    (defbefore-each "Before-each Suite-1" () (setf x 0))
    (defafter-each "After-each Suite-1" () (setf x 1))
    (defafter-all "After-all Suite-1" ((:async done))
      (setf x 1)
      (funcall done))
    (deftest "Test-1" () (eql-p x 0))
    (deftest "Test-2" ((:async done))
      (funcall done (lambda () (eql-p x 0))))))

(run)

bdd

This interface works by define suites inside others suites, but no is provide macros, it provides functions that need of the use of lambda.

(before-all name fn &key async (timeout -1))
(before-each name fn &key async (timeout -1))
(after-each name fn &key async (timeout -1))
(after-all name fn &key async (timeout -1))
(context name fn &key only skip (timeout -1))
(it name fn &key async only skip (timeout -1))

See one example of use:

(defpackage #:cacau-examples-interfaces
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-interfaces)

(context
 "Suite-1"
 (lambda (&optional (x 0))
   (before-all "Before-all Suite-1" (lambda () (setf x 1)))
   (before-each "Before-each Suite-1" (lambda () (setf x 1)))
   (after-each "After-each Suite-1" (lambda () (setf x 1)))
   (after-all "After-all Suite-1" (lambda (done) (funcall done)) :async t)
   (it "Test-1" (lambda () (eql-p x 1)))
   (it "Test-2" (lambda () (incf x) (eql-p x 2)))
   (context
    "Suite-2"
    (lambda (&optional (x 0))
      (it "Test-1" (lambda () (incf x) (eql-p x 1)))
      (it "Test-2" (lambda () (eql-p x 1)))))))
      
(run)

tdd

This interface works by define suites inside others suites, but no is provide macros, it provides functions that need of the use of lambda.

(suite-setup name fn &key async (timeout -1))
(suite-teardown name fn &key async (timeout -1))
(test-setup name fn &key async (timeout -1))
(test-teardown name fn &key async (timeout -1))
(suite name fn &key only skip (timeout -1))
(test name fn &key async only skip (timeout -1))

See one example of use:

(defpackage #:cacau-examples-interfaces
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-interfaces)

(suite
 "Suite-1"
 (lambda (&optional (x 0))
   (suite-setup "Suite-setup Suite-1" (lambda () (setf x 1)))
   (test-setup "Test-setup Suite-1" (lambda () (setf x 1)))
   (test-teardown "Test-teardown Suite-1" (lambda () (setf x 1)))
   (suite-teardown "Suite-teardown Suite-1" (lambda (done) (funcall done)) :async t)
   (test "Test-1" (lambda () (eql-p x 1)))
   (test "Test-2" (lambda () (incf x) (eql-p x 2)))
   (suite
    "Suite-2"
    (lambda (&optional (x 0))
      (test "Test-1" (lambda () (incf x) (eql-p x 1)))
      (test "Test-2" (lambda () (eql-p x 1)))))))
      
(run)

no-spaghetti

This interface works by without define suites inside others suites, it works on the serial way and provide the macros:

(defbefore-plan name options &body body)
(defbefore-t name options &body body)
(defafter-t name options &body body)
(defafter-plan name options &body body)
(in-plan name &optional (options ()))
(deft name &optional (options ()))

The options parameter receive one list that should have zero or more of the following items, in the hooks:

((:async done) (:timeout 0))

in in-plan:

(:skip :only (:async done) (:timeout 0) (:parent :suite-name))

and in deft:

(:skip :only (:async done) (:timeout 0))

This works like this to avoid that you need specify who is the father suite of each test that you write. When you call in-plan, whole next calls of deft or hooks calls will have this suite as father, until you call other in-plan.

See one example of use:

(defpackage #:cacau-examples-interfaces
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-interfaces)

(let ((x 0))
  (in-plan :suite-1 ()) ;; or (in-suite :suite-1 ((:parent :suite-root)))
  (defbefore-plan :before-plan-suite-1 () (setf x 1))
  (deft :test-1 () (eql-p x 1))
  (deft :test-2 ((:async done))
    (incf x)
    (funcall done (lambda () (eql-p x 2))))

  (in-plan :suite-2 ((:parent :suite-1)))
  (defafter-plan :after-plan-suite-2 ((:async done-hook)) (setf x 1) (funcall done-hook))
  (deft :test-1 () (eql-p x 2))
  (deft :test-2 () (incf x) (eql-p x 3))

  (in-plan :suite-3 ((:parent :suite-2)))
  (defbefore-t :before-t-suite-3 () (setf x 0))
  (deft :test-1 () (incf x) (eql-p x 1))
  (deft :test-2 () (eql-p x 0))

  (in-plan :suite-4) ;; or (in-suite :suite-4 ((:parent :suite-root)))
  (defafter-t :after-t-suite-4 () (setf x 0))
  (deft :test-1 () (incf x) (eql-p x 2))
  (deft :test-2 () (eql-p x 0)))
  
  (run)

You can want see the file of the examples of interfaces for better comprehension.

Cacau with colors

The cacau by default don't deliver colorful results, but you can enable the colors in output of the cacau and have one visualization colorful of the reporters result. You need configure the cacau passing the :colorful key argument with the value t for the function (run), see how:

(run :colorful t)

Reporters

The cacau was built in a way support the create new reporters, so you can use whichever you prefer, or even contribute with the cacau project building one new reporter.

You need configure the reporter who chose to use, you should do this passing for (run) the :reporter key argument with the value of the reporter name chosen.

I will introduce the reporters in details order of your outputs, from most basic until the more detailed reporter.

min

This is the cacau's default reporter, when you call (run) without specify some reporter, the cacau will use the :min reporter.

This reporter show very basic information, it output consist in one epilogue saying the running tests quantity and how many passed and failed.

For this code:

(defpackage #:cacau-examples-reporters
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-reporters)

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" (:skip) (t-p t))
  (deftest "Test-3" () (t-p nil)))

(run :colorful t) ;; or (run :colorful t :reporter :min)

The output will be:

reporter min output

list

This rather reporter show more detailed information then :min reporter, it list the suites and tests that are running, and finally show one epilogue saying the running tests quantity and how many passed and failed, and also still provides the quantity of the suites and tests that are configured with skip.

For this code:

(defpackage #:cacau-examples-reporters
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-reporters)

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" (:skip) (t-p t))
  (deftest "Test-3" () (t-p nil)))

(run :colorful t :reporter :list)

The output will be:

reporter list output

full

This rather reporter show more detailed information then :list reporter, it list the suites and tests that are running, and show one epilogue saying all the information of the tests race that cacau can give, and finally show the failing tests with the error messages, provide the option of analyze the full stack that led until that error.

For this code:

(defpackage #:cacau-examples-reporters
  (:use #:common-lisp
        #:assert-p
        #:cacau))
(in-package #:cacau-examples-reporters)

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" () (t-p t))
  (deftest "Test-3" () (t-p nil)))

(run :colorful t :reporter :full)

The output will be:

reporter full output

You can configure the output of the :full reporter passing the :reporter-options key argument for (run) and with this show the information in the order you want, or you can hide the information that don't wish see.

For this code:

(defsuite :suite-1 ()
  (deftest "Test-1" () (t-p t))
  (deftest "Test-2" () (t-p t))
  (deftest "Test-3" () (t-p nil)))

(run :colorful t
     :reporter :full
     :reporter-options
     '(:tests-list
       (:epilogue
        (:run-start
         :run-end
         :run-duration
         :running-suites
         :running-tests
         :passing
         :failing
         :errors))
       :stack))

The output will be:

reporter full with reporter options output

You can want see the file of the examples of reporters for better comprehension.

Enabling the cl-debugger

If you want call the cl-debugger avoiding that the cacau catches the errors, you can do this configuring the cacau when passing :cl-debugger key argument with the value t for the (run) function, see:

(run :cl-debugger t)

Run hooks

If you need execute something before or after of the execution of the (run) function, there are two hooks available for this, you only need pass one key argument for (run):

(run :before-run (lambda () (print "before-run")) 
            :after-run (lambda () (print "after-run")))

Cacau with colors in SLIME

The cacau use ANSI escape codes for print your colorful outputs, and by default the SLIME does not support this.

For enable the use ANSI colors in the SLIME, you will need follow them steps below:

1. Copy "slime-repl-ansi-color.el" file

You will need copy the slime-repl-ansi-color.el file for the directory "contrib" of the SLIME, something as "~/.emacs.d/site-lisp/slime/contrib/", it will depend of how you be configured your EMACS + SLIME.

2. Configure your ".emacs" file

Add the line below in the your EMACS configure file:

(slime-setup '(slime-repl-ansi-color))

It also will depend of how you be configured your EMACS.

3. Enable/disable slime-repl-ansi

For enable:

(slime-repl-ansi-on)

For disable:

(slime-repl-ansi-off)

And finally, in the cacau you just need call (run) passing the :colorful key argument with the value t:

(cacau:run :colorful t)

ASDF Integration

You also can want call the cacau in your ASDF system, to get it, configure your system of tests like this:

(defsystem :cacau-examples-asdf-integration-test
  :depends-on (:cacau-examples-asdf-integration
               :cacau
               :assert-p)
  :defsystem-depends-on (:cacau-asdf)
  :components ((:cacau-file "cacau-examples-asdf-integration-test"))
  :perform (test-op (op c) (symbol-call :cacau '#:run)))

You can want see the directory of example of ASDF integration for better comprehension.

Contributing

The cacau was built to facilitate add new functionalities, as also write new interfaces or reporters. If you have one new idea for make it better, or found come bug, or want contribute of any other way, don't let of open a new issue.

TODO

Provide tests in others CL compilers/interpreters using some CI tool.
Write unit tests for the cacau kernel functions.

API

function (context name fn &key only skip (timeout -1)) => suite

function (before-all name fn &key async (timeout -1)) => suite-before-all

function (after-all name fn &key async (timeout -1)) => suite-after-all

function (before-each name fn &key async (timeout -1)) => suite-before-each

function (after-each name fn &key async (timeout -1)) => suite-after-all

function (it name fn &key async only skip (timeout -1)) => test

function (suite name fn &key only skip (timeout -1)) => suite

function (suite-setup name fn &key async (timeout -1)) => suite-before-all

function (suite-teardown name fn &key async (timeout -1)) => suite-after-all

function (test-setup name fn &key async (timeout -1)) => suite-before-each

function (test-teardown name fn &key async (timeout -1)) => suite-after-each

function (test name fn &key async only skip (timeout -1)) => test

macro (defsuite name options &body body) => suite

macro (defbefore-all name options &body body) => suite-before-all

macro (defafter-all name options &body body) => suite-after-all

macro (defbefore-each name options &body body) => suite-before-each

macro (defafter-each name options &body body) => suite-after-each

macro (deftest name options &body body) => test

macro (in-plan name &optional (options ())) => suite

macro (defbefore-plan name options &body body) => => suite-before-all

macro (defafter-plan name options &body body) => suite-after-all

macro (defbefore-t name options &body body) => suite-before-each

macro (defafter-t name options &body body) => suite-after-each

macro (deft name options &body body) => test

function (run &key (reporter :min) before-run after-run colorful reporter-options cl-debugger) => result

LICENSE

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.

Contact author:

noloop@zoho.com

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 `cacau`

Maintainer

noloop <noloop@zoho.com>

Author

noloop <noloop@zoho.com>

Home Page

https://github.com/noloop/cacau

Source Control

(:git "git@github.com:noloop/cacau.git")

Bug Tracker

https://github.com/noloop/cacau/issues

License

GPLv3

Description

Test Runner in Common Lisp.

Version

1.0.0

Dependencies

eventbus
assertion-error

Source

cacau.asd (file)

Component

src (module)

3 Modules

Modules are listed depth-first from the system components tree.

3.1 `cacau/src`

Parent

cacau (system)

Location

src/

Components

package.lisp (file)
utils.lisp (file)
kernel (module)
reporters (module)
cacau.lisp (file)
interfaces (module)

3.2 `cacau/src/kernel`

Parent

src (module)

Location

src/kernel/

Components

timer.lisp (file)
runnable.lisp (file)
list-iterator.lisp (file)
test.lisp (file)
hook.lisp (file)
suite.lisp (file)
runner-listeners.lisp (file)
runner.lisp (file)

3.3 `cacau/src/reporters`

Parent

src (module)

Location

src/reporters/

Components

base.lisp (file)
min.lisp (file)
list.lisp (file)
full.lisp (file)

3.4 `cacau/src/interfaces`

Parent

src (module)

Location

src/interfaces/

Components

common.lisp (file)
cl.lisp (file)
bdd.lisp (file)
tdd.lisp (file)
no-spaghetti.lisp (file)

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.

4.1 Lisp

4.1.1 `cacau.asd`

Location: cacau.asd
Systems: cacau (system)

4.1.2 `cacau/src/package.lisp`

Parent: src (module)
Location: src/package.lisp
Packages: noloop.cacau

4.1.3 `cacau/src/utils.lisp`

Parent

src (module)

Location

src/utils.lisp

Internal Definitions

create-hash (macro)
create-list-iterator (macro)
defvar* (macro)
read-yes (function)
setf-hash (macro)
string-ansi-color (function)
string-if-not-string (function)
with-gensyms (macro)

4.1.4 `cacau/src/kernel/timer.lisp`

Parent

kernel (module)

Location

src/kernel/timer.lisp

Internal Definitions

duration-ms (method)
(setf duration-ms) (method)
end-ms (method)
(setf end-ms) (method)
end-timer (method)
extrapolated-p (method)
limit-ms (method)
(setf limit-ms) (method)
make-timer (function)
start-ms (method)
(setf start-ms) (method)
start-timer (method)
timer-class (class)

4.1.5 `cacau/src/kernel/runnable.lisp`

Parent

kernel (module)

Location

src/kernel/runnable.lisp

Internal Definitions

after-run (generic function)
cl-debugger-p (method)
(setf cl-debugger-p) (method)
done-runnable (method)
eventbus (method)
(setf eventbus) (method)
fn (method)
(setf fn) (method)
inherit-timeout (method)
name (method)
(setf name) (method)
parent (method)
(setf parent) (method)
run-runnable (generic function)
runnable (class)
runnable-error (method)
(setf runnable-error) (method)
setf-assertion-error (method)
setf-error (method)
start-timeout (method)
timeout (method)
(setf timeout) (method)
timeout-extrapolated-p (method)
timer (method)
(setf timer) (method)
try-fn (method)

4.1.6 `cacau/src/kernel/list-iterator.lisp`

Parent

kernel (module)

Location

src/kernel/list-iterator.lisp

Internal Definitions

add (method)
current-index (method)
(setf current-index) (method)
current-item (method)
done-p (method)
empty-p (method)
itens (method)
(setf itens) (method)
last-p (method)
list-iterator (class)
make-list-iterator (function)
next (method)
start-iterator (method)
start-iterator-reverse (method)

4.1.7 `cacau/src/kernel/test.lisp`

Parent

kernel (module)

Location

src/kernel/test.lisp

Internal Definitions

after-run (method)
async-p (method)
(setf async-p) (method)
make-test (function)
only-p (method)
(setf only-p) (method)
run-runnable (method)
skip-p (method)
(setf skip-p) (method)
test-class (class)

4.1.8 `cacau/src/kernel/hook.lisp`

Parent

kernel (module)

Location

src/kernel/hook.lisp

Internal Definitions

after-run (method)
async-p (method)
(setf async-p) (method)
hook-class (class)
make-hook (function)
pos-hook-fn (method)
(setf pos-hook-fn) (method)
run-runnable (method)

4.1.9 `cacau/src/kernel/suite.lisp`

Parent

kernel (module)

Location

src/kernel/suite.lisp

Exported Definitions

add-child (method)
create-after-all (method)
create-after-each (method)
create-before-all (method)
create-before-each (method)

Internal Definitions

child-by-name (method)
children (method)
(setf children) (method)
collect-after-each-recursive (method)
collect-before-each-recursive (method)
count-suites-recursive (method)
count-tests-recursive (method)
execute-suites-each (method)
has-only-recursive (function)
inherit-only-recursive (method)
init-suite (method)
make-suite (function)
next-child (method)
only-p (method)
(setf only-p) (method)
parents-after-each (method)
(setf parents-after-each) (method)
parents-before-each (method)
(setf parents-before-each) (method)
remove-not-only-children-recursive (method)
remove-skip-children-recursive (method)
run-runnable (method)
skip-p (method)
(setf skip-p) (method)
suite-after-all (method)
(setf suite-after-all) (method)
suite-after-each (method)
(setf suite-after-each) (method)
suite-before-all (method)
(setf suite-before-all) (method)
suite-before-each (method)
(setf suite-before-each) (method)
suite-class (class)

4.1.10 `cacau/src/kernel/runner-listeners.lisp`

Parent: kernel (module)
Location: src/kernel/runner-listeners.lisp
Internal Definitions: create-runner-listeners (function)

4.1.11 `cacau/src/kernel/runner.lisp`

Parent

kernel (module)

Location

src/kernel/runner.lisp

Exported Definitions

create-suite (method)
create-test (method)
make-runner (function)
on-runner (method)
once-runner (method)
result (method)
(setf result) (method)
run-runner (method)
suite-root (method)
(setf suite-root) (method)

Internal Definitions

abort-p (method)
(setf abort-p) (method)
current-suite (method)
(setf current-suite) (method)
eventbus (method)
(setf eventbus) (method)
run-progress (method)
runner (class)

4.1.12 `cacau/src/reporters/base.lisp`

Parent

reporters (module)

Location

src/reporters/base.lisp

Internal Definitions

cacau-logo (function)
create-format-gethash-text-color (function)
custom-result (function)
epilogue (function)
full-epilogue (function)
separation-bar (function)
skipped (function)
stack-test-errors (function)
suite-tests-list-events (function)

4.1.13 `cacau/src/reporters/min.lisp`

Parent: reporters (module)
Location: src/reporters/min.lisp
Internal Definitions: reporter-min (function)

4.1.14 `cacau/src/reporters/list.lisp`

Parent: reporters (module)
Location: src/reporters/list.lisp
Internal Definitions: reporter-list (function)

4.1.15 `cacau/src/reporters/full.lisp`

Parent: reporters (module)
Location: src/reporters/full.lisp
Internal Definitions: reporter-full (function)

4.1.16 `cacau/src/cacau.lisp`

Parent

src (module)

Location

src/cacau.lisp

Exported Definitions

cacau-runner (function)
cl-debugger (function)
reset-runner (function)
run (function)

Internal Definitions

create-reporter (function)
create-reporter-fn (function)

4.1.17 `cacau/src/interfaces/common.lisp`

Parent

interfaces (module)

Location

src/interfaces/common.lisp

Exported Definitions

common-create-after-all (function)
common-create-after-each (function)
common-create-before-all (function)
common-create-before-each (function)
common-create-suite (function)
common-create-test (function)

Internal Definitions

common-create-suite-with-parent (function)
cond-options (macro)

4.1.18 `cacau/src/interfaces/cl.lisp`

Parent

interfaces (module)

Location

src/interfaces/cl.lisp

Exported Definitions

defafter-all (macro)
defafter-each (macro)
defbefore-all (macro)
defbefore-each (macro)
defsuite (macro)
deftest (macro)

4.1.19 `cacau/src/interfaces/bdd.lisp`

Parent

interfaces (module)

Location

src/interfaces/bdd.lisp

Exported Definitions

after-all (function)
after-each (function)
before-all (function)
before-each (function)
context (function)
it (function)

4.1.20 `cacau/src/interfaces/tdd.lisp`

Parent

interfaces (module)

Location

src/interfaces/tdd.lisp

Exported Definitions

suite (function)
suite-setup (function)
suite-teardown (function)
test (function)
test-setup (function)
test-teardown (function)

4.1.21 `cacau/src/interfaces/no-spaghetti.lisp`

Parent

interfaces (module)

Location

src/interfaces/no-spaghetti.lisp

Exported Definitions

defafter-plan (macro)
defafter-t (macro)
defbefore-plan (macro)
defbefore-t (macro)
deft (macro)
in-plan (macro)

5 Packages

Packages are listed by definition order.

5.1 `noloop.cacau`

Source

package.lisp (file)

Nickname

cacau

Use List

common-lisp

Exported Definitions

add-child (generic function)
add-child (method)
after-all (function)
after-each (function)
before-all (function)
before-each (function)
cacau-runner (function)
cl-debugger (function)
common-create-after-all (function)
common-create-after-each (function)
common-create-before-all (function)
common-create-before-each (function)
common-create-suite (function)
common-create-test (function)
context (function)
create-after-all (generic function)
create-after-all (method)
create-after-each (generic function)
create-after-each (method)
create-before-all (generic function)
create-before-all (method)
create-before-each (generic function)
create-before-each (method)
create-suite (generic function)
create-suite (method)
create-test (generic function)
create-test (method)
defafter-all (macro)
defafter-each (macro)
defafter-plan (macro)
defafter-t (macro)
defbefore-all (macro)
defbefore-each (macro)
defbefore-plan (macro)
defbefore-t (macro)
defsuite (macro)
deft (macro)
deftest (macro)
in-plan (macro)
it (function)
make-runner (function)
on-runner (generic function)
on-runner (method)
once-runner (generic function)
once-runner (method)
reset-runner (function)
result (generic function)
result (method)
(setf result) (method)
(setf result) (generic function)
run (function)
run-runner (generic function)
run-runner (method)
suite (function)
suite-root (generic function)
suite-root (method)
(setf suite-root) (method)
(setf suite-root) (generic function)
suite-setup (function)
suite-teardown (function)
test (function)
test-setup (function)
test-teardown (function)

Internal Definitions

abort-p (generic function)
abort-p (method)
(setf abort-p) (method)
(setf abort-p) (generic function)
add (generic function)
add (method)
after-run (generic function)
after-run (method)
after-run (method)
async-p (generic function)
async-p (method)
(setf async-p) (method)
async-p (method)
(setf async-p) (method)
(setf async-p) (generic function)
cacau-logo (function)
child-by-name (generic function)
child-by-name (method)
children (generic function)
children (method)
(setf children) (method)
(setf children) (generic function)
cl-debugger-p (generic function)
cl-debugger-p (method)
(setf cl-debugger-p) (method)
(setf cl-debugger-p) (generic function)
collect-after-each-recursive (generic function)
collect-after-each-recursive (method)
collect-before-each-recursive (generic function)
collect-before-each-recursive (method)
common-create-suite-with-parent (function)
cond-options (macro)
count-suites-recursive (generic function)
count-suites-recursive (method)
count-tests-recursive (generic function)
count-tests-recursive (method)
create-format-gethash-text-color (function)
create-hash (macro)
create-list-iterator (macro)
create-reporter (function)
create-reporter-fn (function)
create-runner-listeners (function)
current-index (generic function)
current-index (method)
(setf current-index) (method)
(setf current-index) (generic function)
current-item (generic function)
current-item (method)
current-suite (generic function)
current-suite (method)
(setf current-suite) (method)
(setf current-suite) (generic function)
custom-result (function)
defvar* (macro)
done-p (generic function)
done-p (method)
done-runnable (generic function)
done-runnable (method)
duration-ms (generic function)
duration-ms (method)
(setf duration-ms) (method)
(setf duration-ms) (generic function)
empty-p (generic function)
empty-p (method)
end-ms (generic function)
end-ms (method)
(setf end-ms) (method)
(setf end-ms) (generic function)
end-timer (generic function)
end-timer (method)
epilogue (function)
eventbus (generic function)
eventbus (method)
(setf eventbus) (method)
eventbus (method)
(setf eventbus) (method)
(setf eventbus) (generic function)
execute-suites-each (generic function)
execute-suites-each (method)
extrapolated-p (generic function)
extrapolated-p (method)
fn (generic function)
fn (method)
(setf fn) (method)
(setf fn) (generic function)
full-epilogue (function)
has-only-recursive (function)
hook-class (class)
inherit-only-recursive (generic function)
inherit-only-recursive (method)
inherit-timeout (generic function)
inherit-timeout (method)
init-suite (generic function)
init-suite (method)
itens (generic function)
itens (method)
(setf itens) (method)
(setf itens) (generic function)
last-p (generic function)
last-p (method)
limit-ms (generic function)
limit-ms (method)
(setf limit-ms) (method)
(setf limit-ms) (generic function)
list-iterator (class)
make-hook (function)
make-list-iterator (function)
make-suite (function)
make-test (function)
make-timer (function)
name (generic function)
name (method)
(setf name) (method)
(setf name) (generic function)
next (generic function)
next (method)
next-child (generic function)
next-child (method)
only-p (generic function)
only-p (method)
(setf only-p) (method)
only-p (method)
(setf only-p) (method)
(setf only-p) (generic function)
parent (generic function)
parent (method)
(setf parent) (method)
(setf parent) (generic function)
parents-after-each (generic function)
parents-after-each (method)
(setf parents-after-each) (method)
(setf parents-after-each) (generic function)
parents-before-each (generic function)
parents-before-each (method)
(setf parents-before-each) (method)
(setf parents-before-each) (generic function)
pos-hook-fn (generic function)
pos-hook-fn (method)
(setf pos-hook-fn) (method)
(setf pos-hook-fn) (generic function)
read-yes (function)
remove-not-only-children-recursive (generic function)
remove-not-only-children-recursive (method)
remove-skip-children-recursive (generic function)
remove-skip-children-recursive (method)
reporter-full (function)
reporter-list (function)
reporter-min (function)
run-progress (generic function)
run-progress (method)
run-runnable (generic function)
run-runnable (method)
run-runnable (method)
run-runnable (method)
runnable (class)
runnable-error (generic function)
runnable-error (method)
(setf runnable-error) (method)
(setf runnable-error) (generic function)
runner (class)
separation-bar (function)
setf-assertion-error (generic function)
setf-assertion-error (method)
setf-error (generic function)
setf-error (method)
setf-hash (macro)
skip-p (generic function)
skip-p (method)
(setf skip-p) (method)
skip-p (method)
(setf skip-p) (method)
(setf skip-p) (generic function)
skipped (function)
stack-test-errors (function)
start-iterator (generic function)
start-iterator (method)
start-iterator-reverse (generic function)
start-iterator-reverse (method)
start-ms (generic function)
start-ms (method)
(setf start-ms) (method)
(setf start-ms) (generic function)
start-timeout (generic function)
start-timeout (method)
start-timer (generic function)
start-timer (method)
string-ansi-color (function)
string-if-not-string (function)
suite-after-all (generic function)
suite-after-all (method)
(setf suite-after-all) (method)
(setf suite-after-all) (generic function)
suite-after-each (generic function)
suite-after-each (method)
(setf suite-after-each) (method)
(setf suite-after-each) (generic function)
suite-before-all (generic function)
suite-before-all (method)
(setf suite-before-all) (method)
(setf suite-before-all) (generic function)
suite-before-each (generic function)
suite-before-each (method)
(setf suite-before-each) (method)
(setf suite-before-each) (generic function)
suite-class (class)
suite-tests-list-events (function)
test-class (class)
timeout (generic function)
timeout (method)
(setf timeout) (method)
(setf timeout) (generic function)
timeout-extrapolated-p (generic function)
timeout-extrapolated-p (method)
timer (generic function)
timer (method)
(setf timer) (method)
(setf timer) (generic function)
timer-class (class)
try-fn (generic function)
try-fn (method)
with-gensyms (macro)

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

6.1 Exported definitions

6.1.1 Macros

Macro: defafter-all NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: defafter-each NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: defafter-plan NAME OPTIONS &body BODY

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

Macro: defafter-t NAME OPTIONS &body BODY

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

Macro: defbefore-all NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: defbefore-each NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: defbefore-plan NAME OPTIONS &body BODY

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

Macro: defbefore-t NAME OPTIONS &body BODY

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

Macro: defsuite NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: deft NAME OPTIONS &body BODY

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

Macro: deftest NAME OPTIONS &body BODY

Package: noloop.cacau
Source: cl.lisp (file)

Macro: in-plan NAME &optional OPTIONS

Package: noloop.cacau
Source: no-spaghetti.lisp (file)

6.1.2 Functions

Function: after-all NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: after-each NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: before-all NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: before-each NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: cacau-runner ()

Package: noloop.cacau
Source: cacau.lisp (file)

Function: cl-debugger OBJ-RUNNABLE ON-OFF

Attention that the slot cl-debugger-p is :allocation :class in runnable class.

Package: noloop.cacau
Source: cacau.lisp (file)

Function: common-create-after-all NAME FN &key ASYNC-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: common-create-after-each NAME FN &key ASYNC-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: common-create-before-all NAME FN &key ASYNC-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: common-create-before-each NAME FN &key ASYNC-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: common-create-suite NAME FN &key ONLY-P SKIP-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: common-create-test NAME FN &key ASYNC-P ONLY-P SKIP-P TIMEOUT

Package: noloop.cacau
Source: common.lisp (file)

Function: context NAME FN &key ONLY SKIP TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: it NAME FN &key ASYNC ONLY SKIP TIMEOUT

Package: noloop.cacau
Source: bdd.lisp (file)

Function: make-runner ()

Package: noloop.cacau
Source: runner.lisp (file)

Function: reset-runner ()

Package: noloop.cacau
Source: cacau.lisp (file)

Function: run &key REPORTER BEFORE-RUN AFTER-RUN COLORFUL REPORTER-OPTIONS CL-DEBUGGER

Package: noloop.cacau
Source: cacau.lisp (file)

Function: suite NAME FN &key ONLY SKIP TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

Function: suite-setup NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

Function: suite-teardown NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

Function: test NAME FN &key ASYNC ONLY SKIP TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

Function: test-setup NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

Function: test-teardown NAME FN &key ASYNC TIMEOUT

Package: noloop.cacau
Source: tdd.lisp (file)

6.1.3 Generic functions

Generic Function: add-child SUITE CHILD

Package

• Introduction		What cacau is all about
• Systems		The systems documentation
• Modules		The modules documentation
• Files		The files documentation
• Packages		The packages documentation
• Definitions		The symbols documentation
• Indexes		Concepts, functions, variables and data types

• The cacau/src module
• The cacau/src/kernel module
• The cacau/src/reporters module
• The cacau/src/interfaces module

• The cacau.asd file
• The cacau/src/package.lisp file
• The cacau/src/utils.lisp file
• The cacau/src/kernel/timer.lisp file
• The cacau/src/kernel/runnable.lisp file
• The cacau/src/kernel/list-iterator.lisp file
• The cacau/src/kernel/test.lisp file
• The cacau/src/kernel/hook.lisp file
• The cacau/src/kernel/suite.lisp file
• The cacau/src/kernel/runner-listeners.lisp file
• The cacau/src/kernel/runner.lisp file
• The cacau/src/reporters/base.lisp file
• The cacau/src/reporters/min.lisp file
• The cacau/src/reporters/list.lisp file
• The cacau/src/reporters/full.lisp file
• The cacau/src/cacau.lisp file
• The cacau/src/interfaces/common.lisp file
• The cacau/src/interfaces/cl.lisp file
• The cacau/src/interfaces/bdd.lisp file
• The cacau/src/interfaces/tdd.lisp file
• The cacau/src/interfaces/no-spaghetti.lisp file

• Exported macros
• Exported functions
• Exported generic functions

• Internal macros
• Internal functions
• Internal generic functions
• Internal classes

• Concept index
• Function index
• Variable index
• Data type index

	Index Entry	Section

C
	`cacau.asd`:	The cacau․asd file
	`cacau/src`:	The cacau/src module
	`cacau/src/cacau.lisp`:	The cacau/src/cacau․lisp file
	`cacau/src/interfaces`:	The cacau/src/interfaces module
	`cacau/src/interfaces/bdd.lisp`:	The cacau/src/interfaces/bdd․lisp file
	`cacau/src/interfaces/cl.lisp`:	The cacau/src/interfaces/cl․lisp file
	`cacau/src/interfaces/common.lisp`:	The cacau/src/interfaces/common․lisp file
	`cacau/src/interfaces/no-spaghetti.lisp`:	The cacau/src/interfaces/no-spaghetti․lisp file
	`cacau/src/interfaces/tdd.lisp`:	The cacau/src/interfaces/tdd․lisp file
	`cacau/src/kernel`:	The cacau/src/kernel module
	`cacau/src/kernel/hook.lisp`:	The cacau/src/kernel/hook․lisp file
	`cacau/src/kernel/list-iterator.lisp`:	The cacau/src/kernel/list-iterator․lisp file
	`cacau/src/kernel/runnable.lisp`:	The cacau/src/kernel/runnable․lisp file
	`cacau/src/kernel/runner-listeners.lisp`:	The cacau/src/kernel/runner-listeners․lisp file
	`cacau/src/kernel/runner.lisp`:	The cacau/src/kernel/runner․lisp file
	`cacau/src/kernel/suite.lisp`:	The cacau/src/kernel/suite․lisp file
	`cacau/src/kernel/test.lisp`:	The cacau/src/kernel/test․lisp file
	`cacau/src/kernel/timer.lisp`:	The cacau/src/kernel/timer․lisp file
	`cacau/src/package.lisp`:	The cacau/src/package․lisp file
	`cacau/src/reporters`:	The cacau/src/reporters module
	`cacau/src/reporters/base.lisp`:	The cacau/src/reporters/base․lisp file
	`cacau/src/reporters/full.lisp`:	The cacau/src/reporters/full․lisp file
	`cacau/src/reporters/list.lisp`:	The cacau/src/reporters/list․lisp file
	`cacau/src/reporters/min.lisp`:	The cacau/src/reporters/min․lisp file
	`cacau/src/utils.lisp`:	The cacau/src/utils․lisp file

F
	File, Lisp, `cacau.asd`:	The cacau․asd file
	File, Lisp, `cacau/src/cacau.lisp`:	The cacau/src/cacau․lisp file
	File, Lisp, `cacau/src/interfaces/bdd.lisp`:	The cacau/src/interfaces/bdd․lisp file
	File, Lisp, `cacau/src/interfaces/cl.lisp`:	The cacau/src/interfaces/cl․lisp file
	File, Lisp, `cacau/src/interfaces/common.lisp`:	The cacau/src/interfaces/common․lisp file
	File, Lisp, `cacau/src/interfaces/no-spaghetti.lisp`:	The cacau/src/interfaces/no-spaghetti․lisp file
	File, Lisp, `cacau/src/interfaces/tdd.lisp`:	The cacau/src/interfaces/tdd․lisp file
	File, Lisp, `cacau/src/kernel/hook.lisp`:	The cacau/src/kernel/hook․lisp file
	File, Lisp, `cacau/src/kernel/list-iterator.lisp`:	The cacau/src/kernel/list-iterator․lisp file
	File, Lisp, `cacau/src/kernel/runnable.lisp`:	The cacau/src/kernel/runnable․lisp file
	File, Lisp, `cacau/src/kernel/runner-listeners.lisp`:	The cacau/src/kernel/runner-listeners․lisp file
	File, Lisp, `cacau/src/kernel/runner.lisp`:	The cacau/src/kernel/runner․lisp file
	File, Lisp, `cacau/src/kernel/suite.lisp`:	The cacau/src/kernel/suite․lisp file
	File, Lisp, `cacau/src/kernel/test.lisp`:	The cacau/src/kernel/test․lisp file
	File, Lisp, `cacau/src/kernel/timer.lisp`:	The cacau/src/kernel/timer․lisp file
	File, Lisp, `cacau/src/package.lisp`:	The cacau/src/package․lisp file
	File, Lisp, `cacau/src/reporters/base.lisp`:	The cacau/src/reporters/base․lisp file
	File, Lisp, `cacau/src/reporters/full.lisp`:	The cacau/src/reporters/full․lisp file
	File, Lisp, `cacau/src/reporters/list.lisp`:	The cacau/src/reporters/list․lisp file
	File, Lisp, `cacau/src/reporters/min.lisp`:	The cacau/src/reporters/min․lisp file
	File, Lisp, `cacau/src/utils.lisp`:	The cacau/src/utils․lisp file

L
	Lisp File, `cacau.asd`:	The cacau․asd file
	Lisp File, `cacau/src/cacau.lisp`:	The cacau/src/cacau․lisp file
	Lisp File, `cacau/src/interfaces/bdd.lisp`:	The cacau/src/interfaces/bdd․lisp file
	Lisp File, `cacau/src/interfaces/cl.lisp`:	The cacau/src/interfaces/cl․lisp file
	Lisp File, `cacau/src/interfaces/common.lisp`:	The cacau/src/interfaces/common․lisp file
	Lisp File, `cacau/src/interfaces/no-spaghetti.lisp`:	The cacau/src/interfaces/no-spaghetti․lisp file
	Lisp File, `cacau/src/interfaces/tdd.lisp`:	The cacau/src/interfaces/tdd․lisp file
	Lisp File, `cacau/src/kernel/hook.lisp`:	The cacau/src/kernel/hook․lisp file
	Lisp File, `cacau/src/kernel/list-iterator.lisp`:	The cacau/src/kernel/list-iterator․lisp file
	Lisp File, `cacau/src/kernel/runnable.lisp`:	The cacau/src/kernel/runnable․lisp file
	Lisp File, `cacau/src/kernel/runner-listeners.lisp`:	The cacau/src/kernel/runner-listeners․lisp file
	Lisp File, `cacau/src/kernel/runner.lisp`:	The cacau/src/kernel/runner․lisp file
	Lisp File, `cacau/src/kernel/suite.lisp`:	The cacau/src/kernel/suite․lisp file
	Lisp File, `cacau/src/kernel/test.lisp`:	The cacau/src/kernel/test․lisp file
	Lisp File, `cacau/src/kernel/timer.lisp`:	The cacau/src/kernel/timer․lisp file
	Lisp File, `cacau/src/package.lisp`:	The cacau/src/package․lisp file
	Lisp File, `cacau/src/reporters/base.lisp`:	The cacau/src/reporters/base․lisp file
	Lisp File, `cacau/src/reporters/full.lisp`:	The cacau/src/reporters/full․lisp file
	Lisp File, `cacau/src/reporters/list.lisp`:	The cacau/src/reporters/list․lisp file
	Lisp File, `cacau/src/reporters/min.lisp`:	The cacau/src/reporters/min․lisp file
	Lisp File, `cacau/src/utils.lisp`:	The cacau/src/utils․lisp file

M
	Module, `cacau/src`:	The cacau/src module
	Module, `cacau/src/interfaces`:	The cacau/src/interfaces module
	Module, `cacau/src/kernel`:	The cacau/src/kernel module
	Module, `cacau/src/reporters`:	The cacau/src/reporters module

	Index Entry	Section

A
	`abort-p`:	Internal classes
	`async-p`:	Internal classes
	`async-p`:	Internal classes

C
	`children`:	Internal classes
	`cl-debugger-p`:	Internal classes
	`current-index`:	Internal classes
	`current-suite`:	Internal classes

D
	`duration-ms`:	Internal classes

E
	`end-ms`:	Internal classes
	`eventbus`:	Internal classes
	`eventbus`:	Internal classes

F
	`fn`:	Internal classes

I
	`itens`:	Internal classes

L
	`limit-ms`:	Internal classes

N
	`name`:	Internal classes

O
	`only-p`:	Internal classes
	`only-p`:	Internal classes

P
	`parent`:	Internal classes
	`parents-after-each`:	Internal classes
	`parents-before-each`:	Internal classes
	`pos-hook-fn`:	Internal classes

R
	`result`:	Internal classes
	`runnable-error`:	Internal classes

S
	`skip-p`:	Internal classes
	`skip-p`:	Internal classes
	`Slot, abort-p`:	Internal classes
	`Slot, async-p`:	Internal classes
	`Slot, async-p`:	Internal classes
	`Slot, children`:	Internal classes
	`Slot, cl-debugger-p`:	Internal classes
	`Slot, current-index`:	Internal classes
	`Slot, current-suite`:	Internal classes
	`Slot, duration-ms`:	Internal classes
	`Slot, end-ms`:	Internal classes
	`Slot, eventbus`:	Internal classes
	`Slot, eventbus`:	Internal classes
	`Slot, fn`:	Internal classes
	`Slot, itens`:	Internal classes
	`Slot, limit-ms`:	Internal classes
	`Slot, name`:	Internal classes
	`Slot, only-p`:	Internal classes
	`Slot, only-p`:	Internal classes
	`Slot, parent`:	Internal classes
	`Slot, parents-after-each`:	Internal classes
	`Slot, parents-before-each`:	Internal classes
	`Slot, pos-hook-fn`:	Internal classes
	`Slot, result`:	Internal classes
	`Slot, runnable-error`:	Internal classes
	`Slot, skip-p`:	Internal classes
	`Slot, skip-p`:	Internal classes
	`Slot, start-ms`:	Internal classes
	`Slot, suite-after-all`:	Internal classes
	`Slot, suite-after-each`:	Internal classes
	`Slot, suite-before-all`:	Internal classes
	`Slot, suite-before-each`:	Internal classes
	`Slot, suite-root`:	Internal classes
	`Slot, timeout`:	Internal classes
	`Slot, timer`:	Internal classes
	`start-ms`:	Internal classes
	`suite-after-all`:	Internal classes
	`suite-after-each`:	Internal classes
	`suite-before-all`:	Internal classes
	`suite-before-each`:	Internal classes
	`suite-root`:	Internal classes

T
	`timeout`:	Internal classes
	`timer`:	Internal classes

	Index Entry	Section

C
	`cacau`:	The cacau system
	`Class, hook-class`:	Internal classes
	`Class, list-iterator`:	Internal classes
	`Class, runnable`:	Internal classes
	`Class, runner`:	Internal classes
	`Class, suite-class`:	Internal classes
	`Class, test-class`:	Internal classes
	`Class, timer-class`:	Internal classes

H
	`hook-class`:	Internal classes

L
	`list-iterator`:	Internal classes

N
	`noloop.cacau`:	The noloop․cacau package

P
	`Package, noloop.cacau`:	The noloop․cacau package

R
	`runnable`:	Internal classes
	`runner`:	Internal classes

S
	`suite-class`:	Internal classes
	`System, cacau`:	The cacau system

T
	`test-class`:	Internal classes
	`timer-class`:	Internal classes

The cacau Reference Manual

Table of Contents

The cacau Reference Manual

1 Introduction

cacau

Read in other languages

Quickstart

Getting Started in cacau

Summary

Portability

Dependencies

Download and Load

Assertions

Functionalities

Suites

Hooks

before all

before each

after each

after all

hooks in :suite-root

Before/after each inheritance

Only and Skip

run only tests/suites

skip tests/suites

precedence order "skip -> only

Timeout

defining suite timeout

defining hook timeout

defining test timeout

Test asynchronous code

Interfaces

cl

bdd

tdd

no-spaghetti

Cacau with colors

Reporters

min

list

full

Enabling the cl-debugger

Run hooks

Cacau with colors in SLIME

ASDF Integration

Contributing

TODO

API

LICENSE

2 Systems

2.1 cacau

3 Modules

3.1 cacau/src

3.2 cacau/src/kernel

3.3 cacau/src/reporters

3.4 cacau/src/interfaces

4 Files

4.1 Lisp

4.1.1 cacau.asd

4.1.2 cacau/src/package.lisp

4.1.3 cacau/src/utils.lisp

4.1.4 cacau/src/kernel/timer.lisp

4.1.5 cacau/src/kernel/runnable.lisp

4.1.6 cacau/src/kernel/list-iterator.lisp

4.1.7 cacau/src/kernel/test.lisp

4.1.8 cacau/src/kernel/hook.lisp

4.1.9 cacau/src/kernel/suite.lisp

4.1.10 cacau/src/kernel/runner-listeners.lisp

4.1.11 cacau/src/kernel/runner.lisp

4.1.12 cacau/src/reporters/base.lisp

4.1.13 cacau/src/reporters/min.lisp

4.1.14 cacau/src/reporters/list.lisp

4.1.15 cacau/src/reporters/full.lisp

4.1.16 cacau/src/cacau.lisp

4.1.17 cacau/src/interfaces/common.lisp

4.1.18 cacau/src/interfaces/cl.lisp

4.1.19 cacau/src/interfaces/bdd.lisp

4.1.20 cacau/src/interfaces/tdd.lisp

4.1.21 cacau/src/interfaces/no-spaghetti.lisp

5 Packages

2.1 `cacau`

3.1 `cacau/src`

3.2 `cacau/src/kernel`

3.3 `cacau/src/reporters`

3.4 `cacau/src/interfaces`

4.1.1 `cacau.asd`

4.1.2 `cacau/src/package.lisp`

4.1.3 `cacau/src/utils.lisp`

4.1.4 `cacau/src/kernel/timer.lisp`

4.1.5 `cacau/src/kernel/runnable.lisp`

4.1.6 `cacau/src/kernel/list-iterator.lisp`

4.1.7 `cacau/src/kernel/test.lisp`

4.1.8 `cacau/src/kernel/hook.lisp`

4.1.9 `cacau/src/kernel/suite.lisp`

4.1.10 `cacau/src/kernel/runner-listeners.lisp`

4.1.11 `cacau/src/kernel/runner.lisp`

4.1.12 `cacau/src/reporters/base.lisp`

4.1.13 `cacau/src/reporters/min.lisp`

4.1.14 `cacau/src/reporters/list.lisp`

4.1.15 `cacau/src/reporters/full.lisp`

4.1.16 `cacau/src/cacau.lisp`

4.1.17 `cacau/src/interfaces/common.lisp`

4.1.18 `cacau/src/interfaces/cl.lisp`

4.1.19 `cacau/src/interfaces/bdd.lisp`

4.1.20 `cacau/src/interfaces/tdd.lisp`

4.1.21 `cacau/src/interfaces/no-spaghetti.lisp`

5.1 `noloop.cacau`