The cacau Reference Manual
Table of Contents
The cacau Reference Manual
This is the cacau Reference Manual, version 1.0.0,
generated automatically by Declt version 3.0 "Montgomery Scott"
on Mon Dec 02 09:09:10 2019 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:

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
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
or
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" ()
(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:

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:

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:

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:

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
Copyright (C) 2019 noloop
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
-
- 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
-
3.2 cacau/src/kernel
- Parent
src (module)
- Location
src/kernel/
- Components
-
3.3 cacau/src/reporters
- Parent
src (module)
- Location
src/reporters/
- Components
-
3.4 cacau/src/interfaces
- Parent
src (module)
- Location
src/interfaces/
- Components
-
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
-
4.1.4 cacau/src/kernel/timer.lisp
- Parent
kernel (module)
- Location
src/kernel/timer.lisp
- Internal Definitions
-
4.1.5 cacau/src/kernel/runnable.lisp
- Parent
kernel (module)
- Location
src/kernel/runnable.lisp
- Internal Definitions
-
4.1.6 cacau/src/kernel/list-iterator.lisp
- Parent
kernel (module)
- Location
src/kernel/list-iterator.lisp
- Internal Definitions
-
4.1.7 cacau/src/kernel/test.lisp
- Parent
kernel (module)
- Location
src/kernel/test.lisp
- Internal Definitions
-
4.1.8 cacau/src/kernel/hook.lisp
- Parent
kernel (module)
- Location
src/kernel/hook.lisp
- Internal Definitions
-
4.1.9 cacau/src/kernel/suite.lisp
- Parent
kernel (module)
- Location
src/kernel/suite.lisp
- Exported Definitions
-
- Internal Definitions
-
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
-
- Internal Definitions
-
4.1.12 cacau/src/reporters/base.lisp
- Parent
reporters (module)
- Location
src/reporters/base.lisp
- Internal Definitions
-
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
-
- Internal Definitions
-
4.1.17 cacau/src/interfaces/common.lisp
- Parent
interfaces (module)
- Location
src/interfaces/common.lisp
- Exported Definitions
-
- Internal Definitions
-
4.1.18 cacau/src/interfaces/cl.lisp
- Parent
interfaces (module)
- Location
src/interfaces/cl.lisp
- Exported Definitions
-
4.1.19 cacau/src/interfaces/bdd.lisp
- Parent
interfaces (module)
- Location
src/interfaces/bdd.lisp
- Exported Definitions
-
4.1.20 cacau/src/interfaces/tdd.lisp
- Parent
interfaces (module)
- Location
src/interfaces/tdd.lisp
- Exported Definitions
-
4.1.21 cacau/src/interfaces/no-spaghetti.lisp
- Parent
interfaces (module)
- Location
src/interfaces/no-spaghetti.lisp
- Exported Definitions
-
5 Packages
Packages are listed by definition order.
5.1 noloop.cacau
- Source
package.lisp (file)
- Nickname
cacau
- Use List
common-lisp
- Exported Definitions
-
- Internal Definitions
-
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
noloop.cacau
- Methods
- Method: add-child (SUITE suite-class) CHILD
-
- Source
suite.lisp (file)
- Generic Function: create-after-all SUITE NAME FN &key ASYNC-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-after-all (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
-
- Source
suite.lisp (file)
- Generic Function: create-after-each SUITE NAME FN &key ASYNC-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-after-each (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
-
- Source
suite.lisp (file)
- Generic Function: create-before-all SUITE NAME FN &key ASYNC-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-before-all (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
-
- Source
suite.lisp (file)
- Generic Function: create-before-each SUITE NAME FN &key ASYNC-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-before-each (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
-
- Source
suite.lisp (file)
- Generic Function: create-suite OBJ NAME &key ONLY-P SKIP-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-suite (OBJ runner) NAME &key ONLY-P SKIP-P TIMEOUT
-
- Source
runner.lisp (file)
- Generic Function: create-test OBJ NAME FN &key ASYNC-P ONLY-P SKIP-P TIMEOUT
-
- Package
noloop.cacau
- Methods
- Method: create-test (OBJ runner) NAME FN &key ASYNC-P ONLY-P SKIP-P TIMEOUT
-
- Source
runner.lisp (file)
- Generic Function: on-runner OBJ EVENT-NAME FN
-
- Package
noloop.cacau
- Methods
- Method: on-runner (OBJ runner) EVENT-NAME FN
-
- Source
runner.lisp (file)
- Generic Function: once-runner OBJ EVENT-NAME FN
-
- Package
noloop.cacau
- Methods
- Method: once-runner (OBJ runner) EVENT-NAME FN
-
- Source
runner.lisp (file)
- Generic Function: result OBJECT
-
- Generic Function: (setf result) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: result (RUNNER runner)
-
automatically generated reader method
- Source
runner.lisp (file)
- Method: (setf result) NEW-VALUE (RUNNER runner)
-
automatically generated writer method
- Source
runner.lisp (file)
- Generic Function: run-runner OBJ
-
- Package
noloop.cacau
- Methods
- Method: run-runner (OBJ runner)
-
- Source
runner.lisp (file)
- Generic Function: suite-root OBJECT
-
- Generic Function: (setf suite-root) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: suite-root (RUNNER runner)
-
automatically generated reader method
- Source
runner.lisp (file)
- Method: (setf suite-root) NEW-VALUE (RUNNER runner)
-
automatically generated writer method
- Source
runner.lisp (file)
6.2 Internal definitions
6.2.1 Macros
- Macro: cond-options OPTIONS &body BODY
-
- Package
noloop.cacau
- Source
common.lisp (file)
- Macro: create-hash &rest FIELDS
-
Example: (create-hash ’((:a 1) (:b 2)))
- Package
noloop.cacau
- Source
utils.lisp (file)
- Macro: create-list-iterator NEW-LIST
-
Creates a new lambda that returns the next item in the new-list reverted. Returns nil if there is not the next item in the list. Example:
(let* ((itens ’(1 2))
(next-item (create-list-iterator itens)))
(print (funcall next-item))
(print (funcall next-item))
(print (funcall next-item)))
=>
1
2
NIL
- Package
noloop.cacau
- Source
utils.lisp (file)
- Macro: defvar* BINDINGS
-
- Package
noloop.cacau
- Source
utils.lisp (file)
- Macro: setf-hash HASH &rest FIELDS
-
Example: (let ((hash (make-hash-table :test ’eq)))
(setf-hash hash ’((:a 1) (:b 2)))
hash)
- Package
noloop.cacau
- Source
utils.lisp (file)
- Macro: with-gensyms VARS &body BODY
-
- Package
noloop.cacau
- Source
utils.lisp (file)
6.2.2 Functions
- Function: cacau-logo ()
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: common-create-suite-with-parent NAME &key ONLY-P SKIP-P TIMEOUT PARENT
-
- Package
noloop.cacau
- Source
common.lisp (file)
- Function: create-format-gethash-text-color RUNNER-RESULT
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: create-reporter RUNNER NAME REPORTER-OPTIONS
-
- Package
noloop.cacau
- Source
cacau.lisp (file)
- Function: create-reporter-fn OLD-RUNNER COLORFUL REPORTER REPORTER-OPTIONS
-
- Package
noloop.cacau
- Source
cacau.lisp (file)
- Function: create-runner-listeners RUNNER
-
- Package
noloop.cacau
- Source
runner-listeners.lisp (file)
- Function: custom-result RUNNER-RESULT OPTIONS
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: epilogue RUNNER-RESULT
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: full-epilogue RUNNER-RESULT OPTIONS
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: has-only-recursive OBJ
-
- Package
noloop.cacau
- Source
suite.lisp (file)
- Function: make-hook &key NAME FN ASYNC-P TIMEOUT EVENTBUS
-
- Package
noloop.cacau
- Source
hook.lisp (file)
- Function: make-list-iterator ()
-
- Package
noloop.cacau
- Source
list-iterator.lisp (file)
- Function: make-suite &key NAME PARENT ONLY-P SKIP-P TIMEOUT EVENTBUS
-
- Package
noloop.cacau
- Source
suite.lisp (file)
- Function: make-test &key NAME FN ASYNC-P ONLY-P SKIP-P TIMEOUT EVENTBUS
-
- Package
noloop.cacau
- Source
test.lisp (file)
- Function: make-timer ()
-
- Package
noloop.cacau
- Source
timer.lisp (file)
- Function: read-yes ()
-
- Package
noloop.cacau
- Source
utils.lisp (file)
- Function: reporter-full RUNNER OPTIONS
-
- Package
noloop.cacau
- Source
full.lisp (file)
- Function: reporter-list RUNNER OPTIONS
-
- Package
noloop.cacau
- Source
list.lisp (file)
- Function: reporter-min RUNNER OPTIONS
-
- Package
noloop.cacau
- Source
min.lisp (file)
- Function: separation-bar &optional COLOR
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: skipped RUNNER-RESULT
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: stack-test-errors RUNNER-RESULT &key REVERSE-LIST
-
- Package
noloop.cacau
- Source
base.lisp (file)
- Function: string-ansi-color STG COLOR &key STYLE BACKGROUND
-
- Package
noloop.cacau
- Source
utils.lisp (file)
- Function: string-if-not-string VALUE
-
- Package
noloop.cacau
- Source
utils.lisp (file)
- Function: suite-tests-list-events RUNNER
-
- Package
noloop.cacau
- Source
base.lisp (file)
6.2.3 Generic functions
- Generic Function: abort-p OBJECT
-
- Generic Function: (setf abort-p) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: abort-p (RUNNER runner)
-
automatically generated reader method
- Source
runner.lisp (file)
- Method: (setf abort-p) NEW-VALUE (RUNNER runner)
-
automatically generated writer method
- Source
runner.lisp (file)
- Generic Function: add OBJ ITEM
-
- Package
noloop.cacau
- Methods
- Method: add (OBJ list-iterator) ITEM
-
- Source
list-iterator.lisp (file)
- Generic Function: after-run OBJ
-
Something must be run after run-runnable.
- Package
noloop.cacau
- Source
runnable.lisp (file)
- Methods
- Method: after-run (HOOK hook-class)
-
- Source
hook.lisp (file)
- Method: after-run (TEST test-class)
-
- Source
test.lisp (file)
- Generic Function: async-p OBJECT
-
- Generic Function: (setf async-p) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: async-p (HOOK-CLASS hook-class)
-
automatically generated reader method
- Source
hook.lisp (file)
- Method: (setf async-p) NEW-VALUE (HOOK-CLASS hook-class)
-
automatically generated writer method
- Source
hook.lisp (file)
- Method: async-p (TEST-CLASS test-class)
-
automatically generated reader method
- Source
test.lisp (file)
- Method: (setf async-p) NEW-VALUE (TEST-CLASS test-class)
-
automatically generated writer method
- Source
test.lisp (file)
- Generic Function: child-by-name SUITE PARENT-NAME
-
- Package
noloop.cacau
- Methods
- Method: child-by-name (SUITE suite-class) PARENT-NAME
-
- Source
suite.lisp (file)
- Generic Function: children OBJECT
-
- Generic Function: (setf children) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: children (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf children) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: cl-debugger-p OBJECT
-
- Generic Function: (setf cl-debugger-p) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: cl-debugger-p (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf cl-debugger-p) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: collect-after-each-recursive SUITE PARENTS-EACH
-
- Package
noloop.cacau
- Methods
- Method: collect-after-each-recursive (SUITE suite-class) PARENTS-EACH
-
- Source
suite.lisp (file)
- Generic Function: collect-before-each-recursive SUITE PARENTS-EACH
-
- Package
noloop.cacau
- Methods
- Method: collect-before-each-recursive (SUITE suite-class) PARENTS-EACH
-
- Source
suite.lisp (file)
- Generic Function: count-suites-recursive LIST
-
- Package
noloop.cacau
- Methods
- Method: count-suites-recursive LIST
-
- Source
suite.lisp (file)
- Generic Function: count-tests-recursive LIST
-
- Package
noloop.cacau
- Methods
- Method: count-tests-recursive LIST
-
- Source
suite.lisp (file)
- Generic Function: current-index OBJECT
-
- Generic Function: (setf current-index) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: current-index (LIST-ITERATOR list-iterator)
-
automatically generated reader method
- Source
list-iterator.lisp (file)
- Method: (setf current-index) NEW-VALUE (LIST-ITERATOR list-iterator)
-
automatically generated writer method
- Source
list-iterator.lisp (file)
- Generic Function: current-item OBJ
-
- Package
noloop.cacau
- Methods
- Method: current-item (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: current-suite OBJECT
-
- Generic Function: (setf current-suite) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: current-suite (RUNNER runner)
-
automatically generated reader method
- Source
runner.lisp (file)
- Method: (setf current-suite) NEW-VALUE (RUNNER runner)
-
automatically generated writer method
- Source
runner.lisp (file)
- Generic Function: done-p OBJ
-
- Package
noloop.cacau
- Methods
- Method: done-p (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: done-runnable OBJ
-
- Package
noloop.cacau
- Methods
- Method: done-runnable (OBJ runnable)
-
- Source
runnable.lisp (file)
- Generic Function: duration-ms OBJECT
-
- Generic Function: (setf duration-ms) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: duration-ms (TIMER-CLASS timer-class)
-
automatically generated reader method
- Source
timer.lisp (file)
- Method: (setf duration-ms) NEW-VALUE (TIMER-CLASS timer-class)
-
automatically generated writer method
- Source
timer.lisp (file)
- Generic Function: empty-p OBJ
-
- Package
noloop.cacau
- Methods
- Method: empty-p (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: end-ms OBJECT
-
- Generic Function: (setf end-ms) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: end-ms (TIMER-CLASS timer-class)
-
automatically generated reader method
- Source
timer.lisp (file)
- Method: (setf end-ms) NEW-VALUE (TIMER-CLASS timer-class)
-
automatically generated writer method
- Source
timer.lisp (file)
- Generic Function: end-timer OBJ
-
- Package
noloop.cacau
- Methods
- Method: end-timer (OBJ timer-class)
-
- Source
timer.lisp (file)
- Generic Function: eventbus OBJECT
-
- Generic Function: (setf eventbus) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: eventbus (RUNNER runner)
-
automatically generated reader method
- Source
runner.lisp (file)
- Method: (setf eventbus) NEW-VALUE (RUNNER runner)
-
automatically generated writer method
- Source
runner.lisp (file)
- Method: eventbus (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf eventbus) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: execute-suites-each SUITE PARENTS-EACH AFTER-HOOK-FN
-
- Package
noloop.cacau
- Methods
- Method: execute-suites-each (SUITE suite-class) PARENTS-EACH AFTER-HOOK-FN
-
- Source
suite.lisp (file)
-
- Package
noloop.cacau
- Methods
-
- Source
timer.lisp (file)
- Generic Function: fn OBJECT
-
- Generic Function: (setf fn) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: fn (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf fn) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: inherit-only-recursive SUITE
-
- Package
noloop.cacau
- Methods
- Method: inherit-only-recursive (SUITE suite-class)
-
- Source
suite.lisp (file)
- Generic Function: inherit-timeout OBJ
-
- Package
noloop.cacau
- Methods
- Method: inherit-timeout (OBJ runnable)
-
- Source
runnable.lisp (file)
- Generic Function: init-suite SUITE
-
- Package
noloop.cacau
- Methods
- Method: init-suite (SUITE suite-class)
-
- Source
suite.lisp (file)
- Generic Function: itens OBJECT
-
- Generic Function: (setf itens) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: itens (LIST-ITERATOR list-iterator)
-
automatically generated reader method
- Source
list-iterator.lisp (file)
- Method: (setf itens) NEW-VALUE (LIST-ITERATOR list-iterator)
-
automatically generated writer method
- Source
list-iterator.lisp (file)
- Generic Function: last-p OBJ
-
- Package
noloop.cacau
- Methods
- Method: last-p (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: limit-ms OBJECT
-
- Generic Function: (setf limit-ms) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: limit-ms (TIMER-CLASS timer-class)
-
automatically generated reader method
- Source
timer.lisp (file)
- Method: (setf limit-ms) NEW-VALUE (TIMER-CLASS timer-class)
-
automatically generated writer method
- Source
timer.lisp (file)
- Generic Function: name OBJECT
-
- Generic Function: (setf name) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: name (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf name) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: next OBJ
-
- Package
noloop.cacau
- Methods
- Method: next (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: next-child SUITE
-
- Package
noloop.cacau
- Methods
- Method: next-child (SUITE suite-class)
-
- Source
suite.lisp (file)
- Generic Function: only-p OBJECT
-
- Generic Function: (setf only-p) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: only-p (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf only-p) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Method: only-p (TEST-CLASS test-class)
-
automatically generated reader method
- Source
test.lisp (file)
- Method: (setf only-p) NEW-VALUE (TEST-CLASS test-class)
-
automatically generated writer method
- Source
test.lisp (file)
- Generic Function: parent OBJECT
-
- Generic Function: (setf parent) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: parent (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf parent) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: parents-after-each OBJECT
-
- Generic Function: (setf parents-after-each) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: parents-after-each (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf parents-after-each) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: parents-before-each OBJECT
-
- Generic Function: (setf parents-before-each) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: parents-before-each (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf parents-before-each) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: pos-hook-fn OBJECT
-
- Generic Function: (setf pos-hook-fn) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: pos-hook-fn (HOOK-CLASS hook-class)
-
automatically generated reader method
- Source
hook.lisp (file)
- Method: (setf pos-hook-fn) NEW-VALUE (HOOK-CLASS hook-class)
-
automatically generated writer method
- Source
hook.lisp (file)
- Generic Function: remove-not-only-children-recursive SUITE
-
- Package
noloop.cacau
- Methods
- Method: remove-not-only-children-recursive (SUITE suite-class)
-
- Source
suite.lisp (file)
- Generic Function: remove-skip-children-recursive SUITE
-
- Package
noloop.cacau
- Methods
- Method: remove-skip-children-recursive (SUITE suite-class)
-
- Source
suite.lisp (file)
- Generic Function: run-progress OBJ
-
- Package
noloop.cacau
- Methods
- Method: run-progress (OBJ runner)
-
- Source
runner.lisp (file)
- Generic Function: run-runnable OBJ &optional FN
-
Something must be run, such as a test suite that calls run-runnable from each tests, or running a hook.
- Package
noloop.cacau
- Source
runnable.lisp (file)
- Methods
- Method: run-runnable (SUITE suite-class) &optional FN
-
- Source
suite.lisp (file)
- Method: run-runnable (HOOK hook-class) &optional AFTER-HOOK
-
- Source
hook.lisp (file)
- Method: run-runnable (TEST test-class) &optional FN
-
- Source
test.lisp (file)
- Generic Function: runnable-error OBJECT
-
- Generic Function: (setf runnable-error) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: runnable-error (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf runnable-error) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: setf-assertion-error OBJ C
-
- Package
noloop.cacau
- Methods
- Method: setf-assertion-error (OBJ runnable) C
-
- Source
runnable.lisp (file)
- Generic Function: setf-error OBJ ERROR-MSG
-
- Package
noloop.cacau
- Methods
- Method: setf-error (OBJ runnable) ERROR-MSG
-
- Source
runnable.lisp (file)
- Generic Function: skip-p OBJECT
-
- Generic Function: (setf skip-p) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: skip-p (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf skip-p) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Method: skip-p (TEST-CLASS test-class)
-
automatically generated reader method
- Source
test.lisp (file)
- Method: (setf skip-p) NEW-VALUE (TEST-CLASS test-class)
-
automatically generated writer method
- Source
test.lisp (file)
- Generic Function: start-iterator OBJ
-
- Package
noloop.cacau
- Methods
- Method: start-iterator (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: start-iterator-reverse OBJ
-
- Package
noloop.cacau
- Methods
- Method: start-iterator-reverse (OBJ list-iterator)
-
- Source
list-iterator.lisp (file)
- Generic Function: start-ms OBJECT
-
- Generic Function: (setf start-ms) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: start-ms (TIMER-CLASS timer-class)
-
automatically generated reader method
- Source
timer.lisp (file)
- Method: (setf start-ms) NEW-VALUE (TIMER-CLASS timer-class)
-
automatically generated writer method
- Source
timer.lisp (file)
- Generic Function: start-timeout OBJ
-
- Package
noloop.cacau
- Methods
- Method: start-timeout (OBJ runnable)
-
- Source
runnable.lisp (file)
- Generic Function: start-timer OBJ
-
- Package
noloop.cacau
- Methods
- Method: start-timer (OBJ timer-class)
-
- Source
timer.lisp (file)
- Generic Function: suite-after-all OBJECT
-
- Generic Function: (setf suite-after-all) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: suite-after-all (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf suite-after-all) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: suite-after-each OBJECT
-
- Generic Function: (setf suite-after-each) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: suite-after-each (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf suite-after-each) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: suite-before-all OBJECT
-
- Generic Function: (setf suite-before-all) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: suite-before-all (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf suite-before-all) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: suite-before-each OBJECT
-
- Generic Function: (setf suite-before-each) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: suite-before-each (SUITE-CLASS suite-class)
-
automatically generated reader method
- Source
suite.lisp (file)
- Method: (setf suite-before-each) NEW-VALUE (SUITE-CLASS suite-class)
-
automatically generated writer method
- Source
suite.lisp (file)
- Generic Function: timeout OBJECT
-
- Generic Function: (setf timeout) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: timeout (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf timeout) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
-
- Package
noloop.cacau
- Methods
-
- Source
runnable.lisp (file)
- Generic Function: timer OBJECT
-
- Generic Function: (setf timer) NEW-VALUE OBJECT
-
- Package
noloop.cacau
- Methods
- Method: timer (RUNNABLE runnable)
-
automatically generated reader method
- Source
runnable.lisp (file)
- Method: (setf timer) NEW-VALUE (RUNNABLE runnable)
-
automatically generated writer method
- Source
runnable.lisp (file)
- Generic Function: try-fn OBJ TRY &key AFTER-ERROR-FN
-
- Package
noloop.cacau
- Methods
- Method: try-fn (OBJ runnable) TRY &key AFTER-ERROR-FN
-
- Source
runnable.lisp (file)
6.2.4 Classes
- Class: hook-class ()
-
- Package
noloop.cacau
- Source
hook.lisp (file)
- Direct superclasses
runnable (class)
- Direct methods
-
- Direct slots
- Slot: async-p
-
- Initargs
:async-p
- Readers
async-p (generic function)
- Writers
(setf async-p) (generic function)
- Slot: pos-hook-fn
-
- Readers
pos-hook-fn (generic function)
- Writers
(setf pos-hook-fn) (generic function)
- Class: list-iterator ()
-
- Package
noloop.cacau
- Source
list-iterator.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
-
- Direct slots
- Slot: itens
-
- Initform
(quote nil)
- Readers
itens (generic function)
- Writers
(setf itens) (generic function)
- Slot: current-index
-
- Initform
0
- Readers
current-index (generic function)
- Writers
(setf current-index) (generic function)
- Class: runnable ()
-
- Package
noloop.cacau
- Source
runnable.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
-
- Direct methods
-
- Direct slots
- Slot: name
-
- Initargs
:name
- Readers
name (generic function)
- Writers
(setf name) (generic function)
- Slot: fn
-
- Initargs
:fn
- Readers
fn (generic function)
- Writers
(setf fn) (generic function)
- Slot: parent
-
- Initargs
:parent
- Readers
parent (generic function)
- Writers
(setf parent) (generic function)
- Slot: runnable-error
-
- Readers
runnable-error (generic function)
- Writers
(setf runnable-error) (generic function)
- Slot: eventbus
-
- Initargs
:eventbus
- Readers
eventbus (generic function)
- Writers
(setf eventbus) (generic function)
- Slot: timer
-
- Initform
(noloop.cacau::make-timer)
- Readers
timer (generic function)
- Writers
(setf timer) (generic function)
- Slot: cl-debugger-p
-
- Allocation
:class
- Readers
cl-debugger-p (generic function)
- Writers
(setf cl-debugger-p) (generic function)
- Slot: timeout
-
- Initargs
:timeout
- Initform
-1
- Readers
timeout (generic function)
- Writers
(setf timeout) (generic function)
- Class: runner ()
-
- Package
noloop.cacau
- Source
runner.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
-
- Direct slots
- Slot: eventbus
-
- Initform
(noloop.eventbus:make-eventbus)
- Readers
eventbus (generic function)
- Writers
(setf eventbus) (generic function)
- Slot: suite-root
-
- Initargs
:suite-root
- Readers
suite-root (generic function)
- Writers
(setf suite-root) (generic function)
- Slot: abort-p
-
- Readers
abort-p (generic function)
- Writers
(setf abort-p) (generic function)
- Slot: result
-
- Initform
(make-hash-table)
- Readers
result (generic function)
- Writers
(setf result) (generic function)
- Slot: current-suite
-
- Readers
current-suite (generic function)
- Writers
(setf current-suite) (generic function)
- Class: suite-class ()
-
- Package
noloop.cacau
- Source
suite.lisp (file)
- Direct superclasses
runnable (class)
- Direct methods
-
- Direct slots
- Slot: suite-before-all
-
- Readers
suite-before-all (generic function)
- Writers
(setf suite-before-all) (generic function)
- Slot: suite-after-all
-
- Readers
suite-after-all (generic function)
- Writers
(setf suite-after-all) (generic function)
- Slot: suite-before-each
-
- Readers
suite-before-each (generic function)
- Writers
(setf suite-before-each) (generic function)
- Slot: suite-after-each
-
- Readers
suite-after-each (generic function)
- Writers
(setf suite-after-each) (generic function)
- Slot: parents-before-each
-
- Initform
(noloop.cacau::make-list-iterator)
- Readers
parents-before-each (generic function)
- Writers
(setf parents-before-each) (generic function)
- Slot: parents-after-each
-
- Initform
(noloop.cacau::make-list-iterator)
- Readers
parents-after-each (generic function)
- Writers
(setf parents-after-each) (generic function)
- Slot: children
-
- Initform
(noloop.cacau::make-list-iterator)
- Readers
children (generic function)
- Writers
(setf children) (generic function)
- Slot: only-p
-
- Initargs
:only-p
- Readers
only-p (generic function)
- Writers
(setf only-p) (generic function)
- Slot: skip-p
-
- Initargs
:skip-p
- Readers
skip-p (generic function)
- Writers
(setf skip-p) (generic function)
- Class: test-class ()
-
- Package
noloop.cacau
- Source
test.lisp (file)
- Direct superclasses
runnable (class)
- Direct methods
-
- Direct slots
- Slot: async-p
-
- Initargs
:async-p
- Readers
async-p (generic function)
- Writers
(setf async-p) (generic function)
- Slot: only-p
-
- Initargs
:only-p
- Readers
only-p (generic function)
- Writers
(setf only-p) (generic function)
- Slot: skip-p
-
- Initargs
:skip-p
- Readers
skip-p (generic function)
- Writers
(setf skip-p) (generic function)
- Class: timer-class ()
-
- Package
noloop.cacau
- Source
timer.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
-
- Direct slots
- Slot: limit-ms
-
- Initargs
:limit-ms
- Initform
-1
- Readers
limit-ms (generic function)
- Writers
(setf limit-ms) (generic function)
- Slot: start-ms
-
- Initargs
:start-ms
- Initform
0
- Readers
start-ms (generic function)
- Writers
(setf start-ms) (generic function)
- Slot: end-ms
-
- Initform
0
- Readers
end-ms (generic function)
- Writers
(setf end-ms) (generic function)
- Slot: duration-ms
-
- Initform
0
- Readers
duration-ms (generic function)
- Writers
(setf duration-ms) (generic function)
Appendix A Indexes
A.1 Concepts
| 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 |
|
A.2 Functions
| Index Entry | | Section |
|
( | | |
| (setf abort-p) : | | Internal generic functions |
| (setf abort-p) : | | Internal generic functions |
| (setf async-p) : | | Internal generic functions |
| (setf async-p) : | | Internal generic functions |
| (setf async-p) : | | Internal generic functions |
| (setf children) : | | Internal generic functions |
| (setf children) : | | Internal generic functions |
| (setf cl-debugger-p) : | | Internal generic functions |
| (setf cl-debugger-p) : | | Internal generic functions |
| (setf current-index) : | | Internal generic functions |
| (setf current-index) : | | Internal generic functions |
| (setf current-suite) : | | Internal generic functions |
| (setf current-suite) : | | Internal generic functions |
| (setf duration-ms) : | | Internal generic functions |
| (setf duration-ms) : | | Internal generic functions |
| (setf end-ms) : | | Internal generic functions |
| (setf end-ms) : | | Internal generic functions |
| (setf eventbus) : | | Internal generic functions |
| (setf eventbus) : | | Internal generic functions |
| (setf eventbus) : | | Internal generic functions |
| (setf fn) : | | Internal generic functions |
| (setf fn) : | | Internal generic functions |
| (setf itens) : | | Internal generic functions |
| (setf itens) : | | Internal generic functions |
| (setf limit-ms) : | | Internal generic functions |
| (setf limit-ms) : | | Internal generic functions |
| (setf name) : | | Internal generic functions |
| (setf name) : | | Internal generic functions |
| (setf only-p) : | | Internal generic functions |
| (setf only-p) : | | Internal generic functions |
| (setf only-p) : | | Internal generic functions |
| (setf parent) : | | Internal generic functions |
| (setf parent) : | | Internal generic functions |
| (setf parents-after-each) : | | Internal generic functions |
| (setf parents-after-each) : | | Internal generic functions |
| (setf parents-before-each) : | | Internal generic functions |
| (setf parents-before-each) : | | Internal generic functions |
| (setf pos-hook-fn) : | | Internal generic functions |
| (setf pos-hook-fn) : | | Internal generic functions |
| (setf result) : | | Exported generic functions |
| (setf result) : | | Exported generic functions |
| (setf runnable-error) : | | Internal generic functions |
| (setf runnable-error) : | | Internal generic functions |
| (setf skip-p) : | | Internal generic functions |
| (setf skip-p) : | | Internal generic functions |
| (setf skip-p) : | | Internal generic functions |
| (setf start-ms) : | | Internal generic functions |
| (setf start-ms) : | | Internal generic functions |
| (setf suite-after-all) : | | Internal generic functions |
| (setf suite-after-all) : | | Internal generic functions |
| (setf suite-after-each) : | | Internal generic functions |
| (setf suite-after-each) : | | Internal generic functions |
| (setf suite-before-all) : | | Internal generic functions |
| (setf suite-before-all) : | | Internal generic functions |
| (setf suite-before-each) : | | Internal generic functions |
| (setf suite-before-each) : | | Internal generic functions |
| (setf suite-root) : | | Exported generic functions |
| (setf suite-root) : | | Exported generic functions |
| (setf timeout) : | | Internal generic functions |
| (setf timeout) : | | Internal generic functions |
| (setf timer) : | | Internal generic functions |
| (setf timer) : | | Internal generic functions |
|
A | | |
| abort-p : | | Internal generic functions |
| abort-p : | | Internal generic functions |
| add : | | Internal generic functions |
| add : | | Internal generic functions |
| add-child : | | Exported generic functions |
| add-child : | | Exported generic functions |
| after-all : | | Exported functions |
| after-each : | | Exported functions |
| after-run : | | Internal generic functions |
| after-run : | | Internal generic functions |
| after-run : | | Internal generic functions |
| async-p : | | Internal generic functions |
| async-p : | | Internal generic functions |
| async-p : | | Internal generic functions |
|
B | | |
| before-all : | | Exported functions |
| before-each : | | Exported functions |
|
C | | |
| cacau-logo : | | Internal functions |
| cacau-runner : | | Exported functions |
| child-by-name : | | Internal generic functions |
| child-by-name : | | Internal generic functions |
| children : | | Internal generic functions |
| children : | | Internal generic functions |
| cl-debugger : | | Exported functions |
| cl-debugger-p : | | Internal generic functions |
| cl-debugger-p : | | Internal generic functions |
| collect-after-each-recursive : | | Internal generic functions |
| collect-after-each-recursive : | | Internal generic functions |
| collect-before-each-recursive : | | Internal generic functions |
| collect-before-each-recursive : | | Internal generic functions |
| common-create-after-all : | | Exported functions |
| common-create-after-each : | | Exported functions |
| common-create-before-all : | | Exported functions |
| common-create-before-each : | | Exported functions |
| common-create-suite : | | Exported functions |
| common-create-suite-with-parent : | | Internal functions |
| common-create-test : | | Exported functions |
| cond-options : | | Internal macros |
| context : | | Exported functions |
| count-suites-recursive : | | Internal generic functions |
| count-suites-recursive : | | Internal generic functions |
| count-tests-recursive : | | Internal generic functions |
| count-tests-recursive : | | Internal generic functions |
| create-after-all : | | Exported generic functions |
| create-after-all : | | Exported generic functions |
| create-after-each : | | Exported generic functions |
| create-after-each : | | Exported generic functions |
| create-before-all : | | Exported generic functions |
| create-before-all : | | Exported generic functions |
| create-before-each : | | Exported generic functions |
| create-before-each : | | Exported generic functions |
| create-format-gethash-text-color : | | Internal functions |
| create-hash : | | Internal macros |
| create-list-iterator : | | Internal macros |
| create-reporter : | | Internal functions |
| create-reporter-fn : | | Internal functions |
| create-runner-listeners : | | Internal functions |
| create-suite : | | Exported generic functions |
| create-suite : | | Exported generic functions |
| create-test : | | Exported generic functions |
| create-test : | | Exported generic functions |
| current-index : | | Internal generic functions |
| current-index : | | Internal generic functions |
| current-item : | | Internal generic functions |
| current-item : | | Internal generic functions |
| current-suite : | | Internal generic functions |
| current-suite : | | Internal generic functions |
| custom-result : | | Internal functions |
|
D | | |
| defafter-all : | | Exported macros |
| defafter-each : | | Exported macros |
| defafter-plan : | | Exported macros |
| defafter-t : | | Exported macros |
| defbefore-all : | | Exported macros |
| defbefore-each : | | Exported macros |
| defbefore-plan : | | Exported macros |
| defbefore-t : | | Exported macros |
| defsuite : | | Exported macros |
| deft : | | Exported macros |
| deftest : | | Exported macros |
| defvar* : | | Internal macros |
| done-p : | | Internal generic functions |
| done-p : | | Internal generic functions |
| done-runnable : | | Internal generic functions |
| done-runnable : | | Internal generic functions |
| duration-ms : | | Internal generic functions |
| duration-ms : | | Internal generic functions |
|
E | | |
| empty-p : | | Internal generic functions |
| empty-p : | | Internal generic functions |
| end-ms : | | Internal generic functions |
| end-ms : | | Internal generic functions |
| end-timer : | | Internal generic functions |
| end-timer : | | Internal generic functions |
| epilogue : | | Internal functions |
| eventbus : | | Internal generic functions |
| eventbus : | | Internal generic functions |
| eventbus : | | Internal generic functions |
| execute-suites-each : | | Internal generic functions |
| execute-suites-each : | | Internal generic functions |
| extrapolated-p : | | Internal generic functions |
| extrapolated-p : | | Internal generic functions |
|
F | | |
| fn : | | Internal generic functions |
| fn : | | Internal generic functions |
| full-epilogue : | | Internal functions |
| Function, after-all : | | Exported functions |
| Function, after-each : | | Exported functions |
| Function, before-all : | | Exported functions |
| Function, before-each : | | Exported functions |
| Function, cacau-logo : | | Internal functions |
| Function, cacau-runner : | | Exported functions |
| Function, cl-debugger : | | Exported functions |
| Function, common-create-after-all : | | Exported functions |
| Function, common-create-after-each : | | Exported functions |
| Function, common-create-before-all : | | Exported functions |
| Function, common-create-before-each : | | Exported functions |
| Function, common-create-suite : | | Exported functions |
| Function, common-create-suite-with-parent : | | Internal functions |
| Function, common-create-test : | | Exported functions |
| Function, context : | | Exported functions |
| Function, create-format-gethash-text-color : | | Internal functions |
| Function, create-reporter : | | Internal functions |
| Function, create-reporter-fn : | | Internal functions |
| Function, create-runner-listeners : | | Internal functions |
| Function, custom-result : | | Internal functions |
| Function, epilogue : | | Internal functions |
| Function, full-epilogue : | | Internal functions |
| Function, has-only-recursive : | | Internal functions |
| Function, it : | | Exported functions |
| Function, make-hook : | | Internal functions |
| Function, make-list-iterator : | | Internal functions |
| Function, make-runner : | | Exported functions |
| Function, make-suite : | | Internal functions |
| Function, make-test : | | Internal functions |
| Function, make-timer : | | Internal functions |
| Function, read-yes : | | Internal functions |
| Function, reporter-full : | | Internal functions |
| Function, reporter-list : | | Internal functions |
| Function, reporter-min : | | Internal functions |
| Function, reset-runner : | | Exported functions |
| Function, run : | | Exported functions |
| Function, separation-bar : | | Internal functions |
| Function, skipped : | | Internal functions |
| Function, stack-test-errors : | | Internal functions |
| Function, string-ansi-color : | | Internal functions |
| Function, string-if-not-string : | | Internal functions |
| Function, suite : | | Exported functions |
| Function, suite-setup : | | Exported functions |
| Function, suite-teardown : | | Exported functions |
| Function, suite-tests-list-events : | | Internal functions |
| Function, test : | | Exported functions |
| Function, test-setup : | | Exported functions |
| Function, test-teardown : | | Exported functions |
|
G | | |
| Generic Function, (setf abort-p) : | | Internal generic functions |
| Generic Function, (setf async-p) : | | Internal generic functions |
| Generic Function, (setf children) : | | Internal generic functions |
| Generic Function, (setf cl-debugger-p) : | | Internal generic functions |
| Generic Function, (setf current-index) : | | Internal generic functions |
| Generic Function, (setf current-suite) : | | Internal generic functions |
| Generic Function, (setf duration-ms) : | | Internal generic functions |
| Generic Function, (setf end-ms) : | | Internal generic functions |
| Generic Function, (setf eventbus) : | | Internal generic functions |
| Generic Function, (setf fn) : | | Internal generic functions |
| Generic Function, (setf itens) : | | Internal generic functions |
| Generic Function, (setf limit-ms) : | | Internal generic functions |
| Generic Function, (setf name) : | | Internal generic functions |
| Generic Function, (setf only-p) : | | Internal generic functions |
| Generic Function, (setf parent) : | | Internal generic functions |
| Generic Function, (setf parents-after-each) : | | Internal generic functions |
| Generic Function, (setf parents-before-each) : | | Internal generic functions |
| Generic Function, (setf pos-hook-fn) : | | Internal generic functions |
| Generic Function, (setf result) : | | Exported generic functions |
| Generic Function, (setf runnable-error) : | | Internal generic functions |
| Generic Function, (setf skip-p) : | | Internal generic functions |
| Generic Function, (setf start-ms) : | | Internal generic functions |
| Generic Function, (setf suite-after-all) : | | Internal generic functions |
| Generic Function, (setf suite-after-each) : | | Internal generic functions |
| Generic Function, (setf suite-before-all) : | | Internal generic functions |
| Generic Function, (setf suite-before-each) : | | Internal generic functions |
| Generic Function, (setf suite-root) : | | Exported generic functions |
| Generic Function, (setf timeout) : | | Internal generic functions |
| Generic Function, (setf timer) : | | Internal generic functions |
| Generic Function, abort-p : | | Internal generic functions |
| Generic Function, add : | | Internal generic functions |
| Generic Function, add-child : | | Exported generic functions |
| Generic Function, after-run : | | Internal generic functions |
| Generic Function, async-p : | | Internal generic functions |
| Generic Function, child-by-name : | | Internal generic functions |
| Generic Function, children : | | Internal generic functions |
| Generic Function, cl-debugger-p : | | Internal generic functions |
| Generic Function, collect-after-each-recursive : | | Internal generic functions |
| Generic Function, collect-before-each-recursive : | | Internal generic functions |
| Generic Function, count-suites-recursive : | | Internal generic functions |
| Generic Function, count-tests-recursive : | | Internal generic functions |
| Generic Function, create-after-all : | | Exported generic functions |
| Generic Function, create-after-each : | | Exported generic functions |
| Generic Function, create-before-all : | | Exported generic functions |
| Generic Function, create-before-each : | | Exported generic functions |
| Generic Function, create-suite : | | Exported generic functions |
| Generic Function, create-test : | | Exported generic functions |
| Generic Function, current-index : | | Internal generic functions |
| Generic Function, current-item : | | Internal generic functions |
| Generic Function, current-suite : | | Internal generic functions |
| Generic Function, done-p : | | Internal generic functions |
| Generic Function, done-runnable : | | Internal generic functions |
| Generic Function, duration-ms : | | Internal generic functions |
| Generic Function, empty-p : | | Internal generic functions |
| Generic Function, end-ms : | | Internal generic functions |
| Generic Function, end-timer : | | Internal generic functions |
| Generic Function, eventbus : | | Internal generic functions |
| Generic Function, execute-suites-each : | | Internal generic functions |
| Generic Function, extrapolated-p : | | Internal generic functions |
| Generic Function, fn : | | Internal generic functions |
| Generic Function, inherit-only-recursive : | | Internal generic functions |
| Generic Function, inherit-timeout : | | Internal generic functions |
| Generic Function, init-suite : | | Internal generic functions |
| Generic Function, itens : | | Internal generic functions |
| Generic Function, last-p : | | Internal generic functions |
| Generic Function, limit-ms : | | Internal generic functions |
| Generic Function, name : | | Internal generic functions |
| Generic Function, next : | | Internal generic functions |
| Generic Function, next-child : | | Internal generic functions |
| Generic Function, on-runner : | | Exported generic functions |
| Generic Function, once-runner : | | Exported generic functions |
| Generic Function, only-p : | | Internal generic functions |
| Generic Function, parent : | | Internal generic functions |
| Generic Function, parents-after-each : | | Internal generic functions |
| Generic Function, parents-before-each : | | Internal generic functions |
| Generic Function, pos-hook-fn : | | Internal generic functions |
| Generic Function, remove-not-only-children-recursive : | | Internal generic functions |
| Generic Function, remove-skip-children-recursive : | | Internal generic functions |
| Generic Function, result : | | Exported generic functions |
| Generic Function, run-progress : | | Internal generic functions |
| Generic Function, run-runnable : | | Internal generic functions |
| Generic Function, run-runner : | | Exported generic functions |
| Generic Function, runnable-error : | | Internal generic functions |
| Generic Function, setf-assertion-error : | | Internal generic functions |
| Generic Function, setf-error : | | Internal generic functions |
| Generic Function, skip-p : | | Internal generic functions |
| Generic Function, start-iterator : | | Internal generic functions |
| Generic Function, start-iterator-reverse : | | Internal generic functions |
| Generic Function, start-ms : | | Internal generic functions |
| Generic Function, start-timeout : | | Internal generic functions |
| Generic Function, start-timer : | | Internal generic functions |
| Generic Function, suite-after-all : | | Internal generic functions |
| Generic Function, suite-after-each : | | Internal generic functions |
| Generic Function, suite-before-all : | | Internal generic functions |
| Generic Function, suite-before-each : | | Internal generic functions |
| Generic Function, suite-root : | | Exported generic functions |
| Generic Function, timeout : | | Internal generic functions |
| Generic Function, timeout-extrapolated-p : | | Internal generic functions |
| Generic Function, timer : | | Internal generic functions |
| Generic Function, try-fn : | | Internal generic functions |
|
H | | |
| has-only-recursive : | | Internal functions |
|
I | | |
| in-plan : | | Exported macros |
| inherit-only-recursive : | | Internal generic functions |
| inherit-only-recursive : | | Internal generic functions |
| inherit-timeout : | | Internal generic functions |
| inherit-timeout : | | Internal generic functions |
| init-suite : | | Internal generic functions |
| init-suite : | | Internal generic functions |
| it : | | Exported functions |
| itens : | | Internal generic functions |
| itens : | | Internal generic functions |
|
L | | |
| last-p : | | Internal generic functions |
| last-p : | | Internal generic functions |
| limit-ms : | | Internal generic functions |
| limit-ms : | | Internal generic functions |
|
M | | |
| Macro, cond-options : | | Internal macros |
| Macro, create-hash : | | Internal macros |
| Macro, create-list-iterator : | | Internal macros |
| Macro, defafter-all : | | Exported macros |
| Macro, defafter-each : | | Exported macros |
| Macro, defafter-plan : | | Exported macros |
| Macro, defafter-t : | | Exported macros |
| Macro, defbefore-all : | | Exported macros |
| Macro, defbefore-each : | | Exported macros |
| Macro, defbefore-plan : | | Exported macros |
| Macro, defbefore-t : | | Exported macros |
| Macro, defsuite : | | Exported macros |
| Macro, deft : | | Exported macros |
| Macro, deftest : | | Exported macros |
| Macro, defvar* : | | Internal macros |
| Macro, in-plan : | | Exported macros |
| Macro, setf-hash : | | Internal macros |
| Macro, with-gensyms : | | Internal macros |
| make-hook : | | Internal functions |
| make-list-iterator : | | Internal functions |
| make-runner : | | Exported functions |
| make-suite : | | Internal functions |
| make-test : | | Internal functions |
| make-timer : | | Internal functions |
| Method, (setf abort-p) : | | Internal generic functions |
| Method, (setf async-p) : | | Internal generic functions |
| Method, (setf async-p) : | | Internal generic functions |
| Method, (setf children) : | | Internal generic functions |
| Method, (setf cl-debugger-p) : | | Internal generic functions |
| Method, (setf current-index) : | | Internal generic functions |
| Method, (setf current-suite) : | | Internal generic functions |
| Method, (setf duration-ms) : | | Internal generic functions |
| Method, (setf end-ms) : | | Internal generic functions |
| Method, (setf eventbus) : | | Internal generic functions |
| Method, (setf eventbus) : | | Internal generic functions |
| Method, (setf fn) : | | Internal generic functions |
| Method, (setf itens) : | | Internal generic functions |
| Method, (setf limit-ms) : | | Internal generic functions |
| Method, (setf name) : | | Internal generic functions |
| Method, (setf only-p) : | | Internal generic functions |
| Method, (setf only-p) : | | Internal generic functions |
| Method, (setf parent) : | | Internal generic functions |
| Method, (setf parents-after-each) : | | Internal generic functions |
| Method, (setf parents-before-each) : | | Internal generic functions |
| Method, (setf pos-hook-fn) : | | Internal generic functions |
| Method, (setf result) : | | Exported generic functions |
| Method, (setf runnable-error) : | | Internal generic functions |
| Method, (setf skip-p) : | | Internal generic functions |
| Method, (setf skip-p) : | | Internal generic functions |
| Method, (setf start-ms) : | | Internal generic functions |
| Method, (setf suite-after-all) : | | Internal generic functions |
| Method, (setf suite-after-each) : | | Internal generic functions |
| Method, (setf suite-before-all) : | | Internal generic functions |
| Method, (setf suite-before-each) : | | Internal generic functions |
| Method, (setf suite-root) : | | Exported generic functions |
| Method, (setf timeout) : | | Internal generic functions |
| Method, (setf timer) : | | Internal generic functions |
| Method, abort-p : | | Internal generic functions |
| Method, add : | | Internal generic functions |
| Method, add-child : | | Exported generic functions |
| Method, after-run : | | Internal generic functions |
| Method, after-run : | | Internal generic functions |
| Method, async-p : | | Internal generic functions |
| Method, async-p : | | Internal generic functions |
| Method, child-by-name : | | Internal generic functions |
| Method, children : | | Internal generic functions |
| Method, cl-debugger-p : | | Internal generic functions |
| Method, collect-after-each-recursive : | | Internal generic functions |
| Method, collect-before-each-recursive : | | Internal generic functions |
| Method, count-suites-recursive : | | Internal generic functions |
| Method, count-tests-recursive : | | Internal generic functions |
| Method, create-after-all : | | Exported generic functions |
| Method, create-after-each : | | Exported generic functions |
| Method, create-before-all : | | Exported generic functions |
| Method, create-before-each : | | Exported generic functions |
| Method, create-suite : | | Exported generic functions |
| Method, create-test : | | Exported generic functions |
| Method, current-index : | | Internal generic functions |
| Method, current-item : | | Internal generic functions |
| Method, current-suite : | | Internal generic functions |
| Method, done-p : | | Internal generic functions |
| Method, done-runnable : | | Internal generic functions |
| Method, duration-ms : | | Internal generic functions |
| Method, empty-p : | | Internal generic functions |
| Method, end-ms : | | Internal generic functions |
| Method, end-timer : | | Internal generic functions |
| Method, eventbus : | | Internal generic functions |
| Method, eventbus : | | Internal generic functions |
| Method, execute-suites-each : | | Internal generic functions |
| Method, extrapolated-p : | | Internal generic functions |
| Method, fn : | | Internal generic functions |
| Method, inherit-only-recursive : | | Internal generic functions |
| Method, inherit-timeout : | | Internal generic functions |
| Method, init-suite : | | Internal generic functions |
| Method, itens : | | Internal generic functions |
| Method, last-p : | | Internal generic functions |
| Method, limit-ms : | | Internal generic functions |
| Method, name : | | Internal generic functions |
| Method, next : | | Internal generic functions |
| Method, next-child : | | Internal generic functions |
| Method, on-runner : | | Exported generic functions |
| Method, once-runner : | | Exported generic functions |
| Method, only-p : | | Internal generic functions |
| Method, only-p : | | Internal generic functions |
| Method, parent : | | Internal generic functions |
| Method, parents-after-each : | | Internal generic functions |
| Method, parents-before-each : | | Internal generic functions |
| Method, pos-hook-fn : | | Internal generic functions |
| Method, remove-not-only-children-recursive : | | Internal generic functions |
| Method, remove-skip-children-recursive : | | Internal generic functions |
| Method, result : | | Exported generic functions |
| Method, run-progress : | | Internal generic functions |
| Method, run-runnable : | | Internal generic functions |
| Method, run-runnable : | | Internal generic functions |
| Method, run-runnable : | | Internal generic functions |
| Method, run-runner : | | Exported generic functions |
| Method, runnable-error : | | Internal generic functions |
| Method, setf-assertion-error : | | Internal generic functions |
| Method, setf-error : | | Internal generic functions |
| Method, skip-p : | | Internal generic functions |
| Method, skip-p : | | Internal generic functions |
| Method, start-iterator : | | Internal generic functions |
| Method, start-iterator-reverse : | | Internal generic functions |
| Method, start-ms : | | Internal generic functions |
| Method, start-timeout : | | Internal generic functions |
| Method, start-timer : | | Internal generic functions |
| Method, suite-after-all : | | Internal generic functions |
| Method, suite-after-each : | | Internal generic functions |
| Method, suite-before-all : | | Internal generic functions |
| Method, suite-before-each : | | Internal generic functions |
| Method, suite-root : | | Exported generic functions |
| Method, timeout : | | Internal generic functions |
| Method, timeout-extrapolated-p : | | Internal generic functions |
| Method, timer : | | Internal generic functions |
| Method, try-fn : | | Internal generic functions |
|
N | | |
| name : | | Internal generic functions |
| name : | | Internal generic functions |
| next : | | Internal generic functions |
| next : | | Internal generic functions |
| next-child : | | Internal generic functions |
| next-child : | | Internal generic functions |
|
O | | |
| on-runner : | | Exported generic functions |
| on-runner : | | Exported generic functions |
| once-runner : | | Exported generic functions |
| once-runner : | | Exported generic functions |
| only-p : | | Internal generic functions |
| only-p : | | Internal generic functions |
| only-p : | | Internal generic functions |
|
P | | |
| parent : | | Internal generic functions |
| parent : | | Internal generic functions |
| parents-after-each : | | Internal generic functions |
| parents-after-each : | | Internal generic functions |
| parents-before-each : | | Internal generic functions |
| parents-before-each : | | Internal generic functions |
| pos-hook-fn : | | Internal generic functions |
| pos-hook-fn : | | Internal generic functions |
|
R | | |
| read-yes : | | Internal functions |
| remove-not-only-children-recursive : | | Internal generic functions |
| remove-not-only-children-recursive : | | Internal generic functions |
| remove-skip-children-recursive : | | Internal generic functions |
| remove-skip-children-recursive : | | Internal generic functions |
| reporter-full : | | Internal functions |
| reporter-list : | | Internal functions |
| reporter-min : | | Internal functions |
| reset-runner : | | Exported functions |
| result : | | Exported generic functions |
| result : | | Exported generic functions |
| run : | | Exported functions |
| run-progress : | | Internal generic functions |
| run-progress : | | Internal generic functions |
| run-runnable : | | Internal generic functions |
| run-runnable : | | Internal generic functions |
| run-runnable : | | Internal generic functions |
| run-runnable : | | Internal generic functions |
| run-runner : | | Exported generic functions |
| run-runner : | | Exported generic functions |
| runnable-error : | | Internal generic functions |
| runnable-error : | | Internal generic functions |
|
S | | |
| separation-bar : | | Internal functions |
| setf-assertion-error : | | Internal generic functions |
| setf-assertion-error : | | Internal generic functions |
| setf-error : | | Internal generic functions |
| setf-error : | | Internal generic functions |
| setf-hash : | | Internal macros |
| skip-p : | | Internal generic functions |
| skip-p : | | Internal generic functions |
| skip-p : | | Internal generic functions |
| skipped : | | Internal functions |
| stack-test-errors : | | Internal functions |
| start-iterator : | | Internal generic functions |
| start-iterator : | | Internal generic functions |
| start-iterator-reverse : | | Internal generic functions |
| start-iterator-reverse : | | Internal generic functions |
| start-ms : | | Internal generic functions |
| start-ms : | | Internal generic functions |
| start-timeout : | | Internal generic functions |
| start-timeout : | | Internal generic functions |
| start-timer : | | Internal generic functions |
| start-timer : | | Internal generic functions |
| string-ansi-color : | | Internal functions |
| string-if-not-string : | | Internal functions |
| suite : | | Exported functions |
| suite-after-all : | | Internal generic functions |
| suite-after-all : | | Internal generic functions |
| suite-after-each : | | Internal generic functions |
| suite-after-each : | | Internal generic functions |
| suite-before-all : | | Internal generic functions |
| suite-before-all : | | Internal generic functions |
| suite-before-each : | | Internal generic functions |
| suite-before-each : | | Internal generic functions |
| suite-root : | | Exported generic functions |
| suite-root : | | Exported generic functions |
| suite-setup : | | Exported functions |
| suite-teardown : | | Exported functions |
| suite-tests-list-events : | | Internal functions |
|
T | | |
| test : | | Exported functions |
| test-setup : | | Exported functions |
| test-teardown : | | Exported functions |
| timeout : | | Internal generic functions |
| timeout : | | Internal generic functions |
| timeout-extrapolated-p : | | Internal generic functions |
| timeout-extrapolated-p : | | Internal generic functions |
| timer : | | Internal generic functions |
| timer : | | Internal generic functions |
| try-fn : | | Internal generic functions |
| try-fn : | | Internal generic functions |
|
W | | |
| with-gensyms : | | Internal macros |
|
A.3 Variables
| 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 |
|
A.4 Data types