The cacau Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The cacau Reference Manual

This is the cacau Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 03:24:17 2022 GMT+0.

Table of Contents


1 Introduction

cacau

Read in other languages

Read this in other languages: English, Portuguese-br

Quickstart

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

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

(run :colorful t)

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

cacau quickstart output by :min reporter

There are also others reporters.

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

Getting Started in cacau

Summary

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:

  1. before-all hook
  2. before-each hook
  3. after-each hook
  4. after-all hook

before all

Do something before all tests of one suite.

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

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

before each

Do something before each test of one suite.

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

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

after each

Do something after each test of one suite.

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

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

after all

Do something after all tests of one suite.

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

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

hooks in :suite-root

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

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

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

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

Before/after each inheritance

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

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

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

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

This will print:

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

For more understanding see the file of hooks examples.

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

Only and Skip

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

run only tests/suites

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

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

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

(run)

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

skip tests/suites

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

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

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

(run :colorful t)

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

precedence order "skip -> only

The rule is simple:

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

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

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

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

Timeout

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

defining suite timeout

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

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

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

defining hook timeout

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

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

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

defining test timeout

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

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

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

(run)

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

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

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

(run)

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

Test asynchronous code

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

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

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

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

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

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

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

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

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

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

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

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

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

Interfaces

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

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

cl

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

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

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

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

in defsuite or deftest:

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

See one example of use:

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

(run)

bdd

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

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

See one example of use:

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

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

tdd

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

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

See one example of use:

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

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

no-spaghetti

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

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

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

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

in in-plan:

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

and in deft:

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

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

See one example of use:

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

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

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

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

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

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

Cacau with colors

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

(run :colorful t)

Reporters

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

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

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

min

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

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

For this code:

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

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

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

The output will be:

reporter min output

list

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

For this code:

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

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

(run :colorful t :reporter :list)

The output will be:

reporter list output

full

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

For this code:

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

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

(run :colorful t :reporter :full)

The output will be:

reporter full output

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

For this code:

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

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

The output will be:

reporter full with reporter options output

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

Enabling the cl-debugger

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

(run :cl-debugger t)

Run hooks

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

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

Cacau with colors in SLIME

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

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

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

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

2. Configure your ".emacs" file

Add the line below in the your EMACS configure file:

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

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

3. Enable/disable slime-repl-ansi

For enable:

(slime-repl-ansi-on)

For disable:

(slime-repl-ansi-off)

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

(cacau:run :colorful t)

ASDF Integration

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

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

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

Contributing

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

TODO

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.


Previous: , Up: Systems   [Contents][Index]

2.1 cacau

Test Runner in Common Lisp.

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

Version

1.0.0

Dependencies
  • eventbus (system).
  • assertion-error (system).
Source

cacau.asd.

Child Component

src (module).


Next: , Previous: , Up: The cacau Reference Manual   [Contents][Index]

3 Modules

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


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 cacau/src

Source

cacau.asd.

Parent Component

cacau (system).

Child Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.2 cacau/src/kernel

Source

cacau.asd.

Parent Component

src (module).

Child Components

3.3 cacau/src/reporters

Source

cacau.asd.

Parent Component

src (module).

Child Components

Previous: , Up: Modules   [Contents][Index]

3.4 cacau/src/interfaces

Source

cacau.asd.

Parent Component

src (module).

Child Components

4 Files

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


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

4.1.1 cacau/cacau.asd

Source

cacau.asd.

Parent Component

cacau (system).

ASDF Systems

cacau.


4.1.2 cacau/src/package.lisp

Source

cacau.asd.

Parent Component

src (module).

Packages

noloop.cacau.


4.1.3 cacau/src/utils.lisp

Source

cacau.asd.

Parent Component

src (module).

Internals

4.1.4 cacau/src/kernel/timer.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Internals

4.1.5 cacau/src/kernel/runnable.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Internals

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

Source

cacau.asd.

Parent Component

kernel (module).

Internals

4.1.7 cacau/src/kernel/test.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Internals

4.1.8 cacau/src/kernel/hook.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Internals

4.1.9 cacau/src/kernel/suite.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Public Interface
Internals

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

Source

cacau.asd.

Parent Component

kernel (module).

Internals

create-runner-listeners (function).


4.1.11 cacau/src/kernel/runner.lisp

Source

cacau.asd.

Parent Component

kernel (module).

Public Interface
Internals

4.1.12 cacau/src/reporters/base.lisp

Source

cacau.asd.

Parent Component

reporters (module).

Internals

4.1.13 cacau/src/reporters/min.lisp

Source

cacau.asd.

Parent Component

reporters (module).

Internals

reporter-min (function).


4.1.14 cacau/src/reporters/list.lisp

Source

cacau.asd.

Parent Component

reporters (module).

Internals

reporter-list (function).


4.1.15 cacau/src/reporters/full.lisp

Source

cacau.asd.

Parent Component

reporters (module).

Internals

reporter-full (function).


4.1.16 cacau/src/cacau.lisp

Source

cacau.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.17 cacau/src/interfaces/common.lisp

Source

cacau.asd.

Parent Component

interfaces (module).

Public Interface
Internals

4.1.18 cacau/src/interfaces/cl.lisp

Source

cacau.asd.

Parent Component

interfaces (module).

Public Interface

4.1.19 cacau/src/interfaces/bdd.lisp

Source

cacau.asd.

Parent Component

interfaces (module).

Public Interface

4.1.20 cacau/src/interfaces/tdd.lisp

Source

cacau.asd.

Parent Component

interfaces (module).

Public Interface

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

Source

cacau.asd.

Parent Component

interfaces (module).

Public Interface

5 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

5.1 noloop.cacau

Source

package.lisp.

Nickname

cacau

Use List

common-lisp.

Public Interface
Internals

6 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Public Interface


6.1.1 Macros

Macro: defafter-all (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: defafter-each (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: defafter-plan (name options &body body)
Package

noloop.cacau.

Source

no-spaghetti.lisp.

Macro: defafter-t (name options &body body)
Package

noloop.cacau.

Source

no-spaghetti.lisp.

Macro: defbefore-all (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: defbefore-each (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: defbefore-plan (name options &body body)
Package

noloop.cacau.

Source

no-spaghetti.lisp.

Macro: defbefore-t (name options &body body)
Package

noloop.cacau.

Source

no-spaghetti.lisp.

Macro: defsuite (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: deft (name options &body body)
Package

noloop.cacau.

Source

no-spaghetti.lisp.

Macro: deftest (name options &body body)
Package

noloop.cacau.

Source

cl.lisp.

Macro: in-plan (name &optional options)
Package

noloop.cacau.

Source

no-spaghetti.lisp.


6.1.2 Ordinary functions

Function: after-all (name fn &key async timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: after-each (name fn &key async timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: before-all (name fn &key async timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: before-each (name fn &key async timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: cacau-runner ()
Package

noloop.cacau.

Source

cacau.lisp.

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.

Function: common-create-after-all (name fn &key async-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: common-create-after-each (name fn &key async-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: common-create-before-all (name fn &key async-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: common-create-before-each (name fn &key async-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: common-create-suite (name fn &key only-p skip-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: common-create-test (name fn &key async-p only-p skip-p timeout)
Package

noloop.cacau.

Source

common.lisp.

Function: context (name fn &key only skip timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: it (name fn &key async only skip timeout)
Package

noloop.cacau.

Source

bdd.lisp.

Function: make-runner ()
Package

noloop.cacau.

Source

runner.lisp.

Function: reset-runner ()
Package

noloop.cacau.

Source

cacau.lisp.

Function: run (&key reporter before-run after-run colorful reporter-options cl-debugger)
Package

noloop.cacau.

Source

cacau.lisp.

Function: suite (name fn &key only skip timeout)
Package

noloop.cacau.

Source

tdd.lisp.

Function: suite-setup (name fn &key async timeout)
Package

noloop.cacau.

Source

tdd.lisp.

Function: suite-teardown (name fn &key async timeout)
Package

noloop.cacau.

Source

tdd.lisp.

Function: test (name fn &key async only skip timeout)
Package

noloop.cacau.

Source

tdd.lisp.

Function: test-setup (name fn &key async timeout)
Package

noloop.cacau.

Source

tdd.lisp.

Function: test-teardown (name fn &key async timeout)
Package

noloop.cacau.

Source

tdd.lisp.


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.

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.

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.

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.

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.

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.

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.

Generic Function: on-runner (obj event-name fn)
Package

noloop.cacau.

Methods
Method: on-runner ((obj runner) event-name fn)
Source

runner.lisp.

Generic Function: once-runner (obj event-name fn)
Package

noloop.cacau.

Methods
Method: once-runner ((obj runner) event-name fn)
Source

runner.lisp.

Generic Reader: result (object)
Package

noloop.cacau.

Methods
Reader Method: result ((runner runner))

automatically generated reader method

Source

runner.lisp.

Target Slot

result.

Generic Writer: (setf result) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf result) ((runner runner))

automatically generated writer method

Source

runner.lisp.

Target Slot

result.

Generic Function: run-runner (obj)
Package

noloop.cacau.

Methods
Method: run-runner ((obj runner))
Source

runner.lisp.

Generic Reader: suite-root (object)
Package

noloop.cacau.

Methods
Reader Method: suite-root ((runner runner))

automatically generated reader method

Source

runner.lisp.

Target Slot

suite-root.

Generic Writer: (setf suite-root) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf suite-root) ((runner runner))

automatically generated writer method

Source

runner.lisp.

Target Slot

suite-root.


6.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.1 Macros

Macro: cond-options (options &body body)
Package

noloop.cacau.

Source

common.lisp.

Macro: create-hash (&rest fields)

Example: (create-hash ’((:a 1) (:b 2)))

Package

noloop.cacau.

Source

utils.lisp.

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.

Macro: defvar* (bindings)
Package

noloop.cacau.

Source

utils.lisp.

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.

Macro: with-gensyms (vars &body body)
Package

noloop.cacau.

Source

utils.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.2 Ordinary functions

Package

noloop.cacau.

Source

base.lisp.

Function: common-create-suite-with-parent (name &key only-p skip-p timeout parent)
Package

noloop.cacau.

Source

common.lisp.

Function: create-format-gethash-text-color (runner-result)
Package

noloop.cacau.

Source

base.lisp.

Function: create-reporter (runner name reporter-options)
Package

noloop.cacau.

Source

cacau.lisp.

Function: create-reporter-fn (old-runner colorful reporter reporter-options)
Package

noloop.cacau.

Source

cacau.lisp.

Function: create-runner-listeners (runner)
Package

noloop.cacau.

Source

runner-listeners.lisp.

Function: custom-result (runner-result options)
Package

noloop.cacau.

Source

base.lisp.

Function: epilogue (runner-result)
Package

noloop.cacau.

Source

base.lisp.

Function: full-epilogue (runner-result options)
Package

noloop.cacau.

Source

base.lisp.

Function: has-only-recursive (obj)
Package

noloop.cacau.

Source

suite.lisp.

Function: make-hook (&key name fn async-p timeout eventbus)
Package

noloop.cacau.

Source

hook.lisp.

Function: make-list-iterator ()
Package

noloop.cacau.

Source

list-iterator.lisp.

Function: make-suite (&key name parent only-p skip-p timeout eventbus)
Package

noloop.cacau.

Source

suite.lisp.

Function: make-test (&key name fn async-p only-p skip-p timeout eventbus)
Package

noloop.cacau.

Source

test.lisp.

Function: make-timer ()
Package

noloop.cacau.

Source

timer.lisp.

Function: read-yes ()
Package

noloop.cacau.

Source

utils.lisp.

Function: reporter-full (runner options)
Package

noloop.cacau.

Source

full.lisp.

Function: reporter-list (runner options)
Package

noloop.cacau.

Source

list.lisp.

Function: reporter-min (runner options)
Package

noloop.cacau.

Source

min.lisp.

Function: separation-bar (&optional color)
Package

noloop.cacau.

Source

base.lisp.

Function: skipped (runner-result)
Package

noloop.cacau.

Source

base.lisp.

Function: stack-test-errors (runner-result &key reverse-list)
Package

noloop.cacau.

Source

base.lisp.

Function: string-ansi-color (stg color &key style background)
Package

noloop.cacau.

Source

utils.lisp.

Function: string-if-not-string (value)
Package

noloop.cacau.

Source

utils.lisp.

Function: suite-tests-list-events (runner)
Package

noloop.cacau.

Source

base.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

6.2.3 Generic functions

Generic Reader: abort-p (object)
Package

noloop.cacau.

Methods
Reader Method: abort-p ((runner runner))

automatically generated reader method

Source

runner.lisp.

Target Slot

abort-p.

Generic Writer: (setf abort-p) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf abort-p) ((runner runner))

automatically generated writer method

Source

runner.lisp.

Target Slot

abort-p.

Generic Function: add (obj item)
Package

noloop.cacau.

Methods
Method: add ((obj list-iterator) item)
Source

list-iterator.lisp.

Generic Function: after-run (obj)

Something must be run after run-runnable.

Package

noloop.cacau.

Source

runnable.lisp.

Methods
Method: after-run ((hook hook-class))
Source

hook.lisp.

Method: after-run ((test test-class))
Source

test.lisp.

Generic Reader: async-p (object)
Package

noloop.cacau.

Methods
Reader Method: async-p ((hook-class hook-class))

automatically generated reader method

Source

hook.lisp.

Target Slot

async-p.

Reader Method: async-p ((test-class test-class))

automatically generated reader method

Source

test.lisp.

Target Slot

async-p.

Generic Writer: (setf async-p) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf async-p) ((hook-class hook-class))

automatically generated writer method

Source

hook.lisp.

Target Slot

async-p.

Writer Method: (setf async-p) ((test-class test-class))

automatically generated writer method

Source

test.lisp.

Target Slot

async-p.

Generic Function: child-by-name (suite parent-name)
Package

noloop.cacau.

Methods
Method: child-by-name ((suite suite-class) parent-name)
Source

suite.lisp.

Generic Reader: children (object)
Package

noloop.cacau.

Methods
Reader Method: children ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

children.

Generic Writer: (setf children) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf children) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

children.

Generic Reader: cl-debugger-p (object)
Package

noloop.cacau.

Methods
Reader Method: cl-debugger-p ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

cl-debugger-p.

Generic Writer: (setf cl-debugger-p) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf cl-debugger-p) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

cl-debugger-p.

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.

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.

Generic Function: count-suites-recursive (list)
Package

noloop.cacau.

Methods
Method: count-suites-recursive (list)
Source

suite.lisp.

Generic Function: count-tests-recursive (list)
Package

noloop.cacau.

Methods
Method: count-tests-recursive (list)
Source

suite.lisp.

Generic Reader: current-index (object)
Package

noloop.cacau.

Methods
Reader Method: current-index ((list-iterator list-iterator))

automatically generated reader method

Source

list-iterator.lisp.

Target Slot

current-index.

Generic Writer: (setf current-index) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf current-index) ((list-iterator list-iterator))

automatically generated writer method

Source

list-iterator.lisp.

Target Slot

current-index.

Generic Function: current-item (obj)
Package

noloop.cacau.

Methods
Method: current-item ((obj list-iterator))
Source

list-iterator.lisp.

Generic Reader: current-suite (object)
Package

noloop.cacau.

Methods
Reader Method: current-suite ((runner runner))

automatically generated reader method

Source

runner.lisp.

Target Slot

current-suite.

Generic Writer: (setf current-suite) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf current-suite) ((runner runner))

automatically generated writer method

Source

runner.lisp.

Target Slot

current-suite.

Generic Function: done-p (obj)
Package

noloop.cacau.

Methods
Method: done-p ((obj list-iterator))
Source

list-iterator.lisp.

Generic Function: done-runnable (obj)
Package

noloop.cacau.

Methods
Method: done-runnable ((obj runnable))
Source

runnable.lisp.

Generic Reader: duration-ms (object)
Package

noloop.cacau.

Methods
Reader Method: duration-ms ((timer-class timer-class))

automatically generated reader method

Source

timer.lisp.

Target Slot

duration-ms.

Generic Writer: (setf duration-ms) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf duration-ms) ((timer-class timer-class))

automatically generated writer method

Source

timer.lisp.

Target Slot

duration-ms.

Generic Function: empty-p (obj)
Package

noloop.cacau.

Methods
Method: empty-p ((obj list-iterator))
Source

list-iterator.lisp.

Generic Reader: end-ms (object)
Package

noloop.cacau.

Methods
Reader Method: end-ms ((timer-class timer-class))

automatically generated reader method

Source

timer.lisp.

Target Slot

end-ms.

Generic Writer: (setf end-ms) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf end-ms) ((timer-class timer-class))

automatically generated writer method

Source

timer.lisp.

Target Slot

end-ms.

Generic Function: end-timer (obj)
Package

noloop.cacau.

Methods
Method: end-timer ((obj timer-class))
Source

timer.lisp.

Generic Reader: eventbus (object)
Package

noloop.cacau.

Methods
Reader Method: eventbus ((runner runner))

automatically generated reader method

Source

runner.lisp.

Target Slot

eventbus.

Reader Method: eventbus ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

eventbus.

Generic Writer: (setf eventbus) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf eventbus) ((runner runner))

automatically generated writer method

Source

runner.lisp.

Target Slot

eventbus.

Writer Method: (setf eventbus) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

eventbus.

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.

Generic Function: extrapolated-p (obj)
Package

noloop.cacau.

Methods
Method: extrapolated-p ((obj timer-class))
Source

timer.lisp.

Generic Reader: fn (object)
Package

noloop.cacau.

Methods
Reader Method: fn ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

fn.

Generic Writer: (setf fn) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf fn) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

fn.

Generic Function: inherit-only-recursive (suite)
Package

noloop.cacau.

Methods
Method: inherit-only-recursive ((suite suite-class))
Source

suite.lisp.

Generic Function: inherit-timeout (obj)
Package

noloop.cacau.

Methods
Method: inherit-timeout ((obj runnable))
Source

runnable.lisp.

Generic Function: init-suite (suite)
Package

noloop.cacau.

Methods
Method: init-suite ((suite suite-class))
Source

suite.lisp.

Generic Reader: itens (object)
Package

noloop.cacau.

Methods
Reader Method: itens ((list-iterator list-iterator))

automatically generated reader method

Source

list-iterator.lisp.

Target Slot

itens.

Generic Writer: (setf itens) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf itens) ((list-iterator list-iterator))

automatically generated writer method

Source

list-iterator.lisp.

Target Slot

itens.

Generic Function: last-p (obj)
Package

noloop.cacau.

Methods
Method: last-p ((obj list-iterator))
Source

list-iterator.lisp.

Generic Reader: limit-ms (object)
Package

noloop.cacau.

Methods
Reader Method: limit-ms ((timer-class timer-class))

automatically generated reader method

Source

timer.lisp.

Target Slot

limit-ms.

Generic Writer: (setf limit-ms) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf limit-ms) ((timer-class timer-class))

automatically generated writer method

Source

timer.lisp.

Target Slot

limit-ms.

Generic Reader: name (object)
Package

noloop.cacau.

Methods
Reader Method: name ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

name.

Generic Writer: (setf name) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf name) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

name.

Generic Function: next (obj)
Package

noloop.cacau.

Methods
Method: next ((obj list-iterator))
Source

list-iterator.lisp.

Generic Function: next-child (suite)
Package

noloop.cacau.

Methods
Method: next-child ((suite suite-class))
Source

suite.lisp.

Generic Reader: only-p (object)
Package

noloop.cacau.

Methods
Reader Method: only-p ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

only-p.

Reader Method: only-p ((test-class test-class))

automatically generated reader method

Source

test.lisp.

Target Slot

only-p.

Generic Writer: (setf only-p) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf only-p) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

only-p.

Writer Method: (setf only-p) ((test-class test-class))

automatically generated writer method

Source

test.lisp.

Target Slot

only-p.

Generic Reader: parent (object)
Package

noloop.cacau.

Methods
Reader Method: parent ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

parent.

Generic Writer: (setf parent) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf parent) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

parent.

Generic Reader: parents-after-each (object)
Package

noloop.cacau.

Methods
Reader Method: parents-after-each ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

parents-after-each.

Generic Writer: (setf parents-after-each) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf parents-after-each) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

parents-after-each.

Generic Reader: parents-before-each (object)
Package

noloop.cacau.

Methods
Reader Method: parents-before-each ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

parents-before-each.

Generic Writer: (setf parents-before-each) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf parents-before-each) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

parents-before-each.

Generic Reader: pos-hook-fn (object)
Package

noloop.cacau.

Methods
Reader Method: pos-hook-fn ((hook-class hook-class))

automatically generated reader method

Source

hook.lisp.

Target Slot

pos-hook-fn.

Generic Writer: (setf pos-hook-fn) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf pos-hook-fn) ((hook-class hook-class))

automatically generated writer method

Source

hook.lisp.

Target Slot

pos-hook-fn.

Generic Function: remove-not-only-children-recursive (suite)
Package

noloop.cacau.

Methods
Method: remove-not-only-children-recursive ((suite suite-class))
Source

suite.lisp.

Generic Function: remove-skip-children-recursive (suite)
Package

noloop.cacau.

Methods
Method: remove-skip-children-recursive ((suite suite-class))
Source

suite.lisp.

Generic Function: run-progress (obj)
Package

noloop.cacau.

Methods
Method: run-progress ((obj runner))
Source

runner.lisp.

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.

Methods
Method: run-runnable ((suite suite-class) &optional fn)
Source

suite.lisp.

Method: run-runnable ((hook hook-class) &optional after-hook)
Source

hook.lisp.

Method: run-runnable ((test test-class) &optional fn)
Source

test.lisp.

Generic Reader: runnable-error (object)
Package

noloop.cacau.

Methods
Reader Method: runnable-error ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

runnable-error.

Generic Writer: (setf runnable-error) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf runnable-error) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

runnable-error.

Generic Function: setf-assertion-error (obj c)
Package

noloop.cacau.

Methods
Method: setf-assertion-error ((obj runnable) c)
Source

runnable.lisp.

Generic Function: setf-error (obj error-msg)
Package

noloop.cacau.

Methods
Method: setf-error ((obj runnable) error-msg)
Source

runnable.lisp.

Generic Reader: skip-p (object)
Package

noloop.cacau.

Methods
Reader Method: skip-p ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

skip-p.

Reader Method: skip-p ((test-class test-class))

automatically generated reader method

Source

test.lisp.

Target Slot

skip-p.

Generic Writer: (setf skip-p) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf skip-p) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

skip-p.

Writer Method: (setf skip-p) ((test-class test-class))

automatically generated writer method

Source

test.lisp.

Target Slot

skip-p.

Generic Function: start-iterator (obj)
Package

noloop.cacau.

Methods
Method: start-iterator ((obj list-iterator))
Source

list-iterator.lisp.

Generic Function: start-iterator-reverse (obj)
Package

noloop.cacau.

Methods
Method: start-iterator-reverse ((obj list-iterator))
Source

list-iterator.lisp.

Generic Reader: start-ms (object)
Package

noloop.cacau.

Methods
Reader Method: start-ms ((timer-class timer-class))

automatically generated reader method

Source

timer.lisp.

Target Slot

start-ms.

Generic Writer: (setf start-ms) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf start-ms) ((timer-class timer-class))

automatically generated writer method

Source

timer.lisp.

Target Slot

start-ms.

Generic Function: start-timeout (obj)
Package

noloop.cacau.

Methods
Method: start-timeout ((obj runnable))
Source

runnable.lisp.

Generic Function: start-timer (obj)
Package

noloop.cacau.

Methods
Method: start-timer ((obj timer-class))
Source

timer.lisp.

Generic Reader: suite-after-all (object)
Package

noloop.cacau.

Methods
Reader Method: suite-after-all ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

suite-after-all.

Generic Writer: (setf suite-after-all) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf suite-after-all) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

suite-after-all.

Generic Reader: suite-after-each (object)
Package

noloop.cacau.

Methods
Reader Method: suite-after-each ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

suite-after-each.

Generic Writer: (setf suite-after-each) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf suite-after-each) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

suite-after-each.

Generic Reader: suite-before-all (object)
Package

noloop.cacau.

Methods
Reader Method: suite-before-all ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

suite-before-all.

Generic Writer: (setf suite-before-all) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf suite-before-all) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

suite-before-all.

Generic Reader: suite-before-each (object)
Package

noloop.cacau.

Methods
Reader Method: suite-before-each ((suite-class suite-class))

automatically generated reader method

Source

suite.lisp.

Target Slot

suite-before-each.

Generic Writer: (setf suite-before-each) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf suite-before-each) ((suite-class suite-class))

automatically generated writer method

Source

suite.lisp.

Target Slot

suite-before-each.

Generic Reader: timeout (object)
Package

noloop.cacau.

Methods
Reader Method: timeout ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

timeout.

Generic Writer: (setf timeout) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf timeout) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

timeout.

Generic Function: timeout-extrapolated-p (obj)
Package

noloop.cacau.

Methods
Method: timeout-extrapolated-p ((obj runnable))
Source

runnable.lisp.

Generic Reader: timer (object)
Package

noloop.cacau.

Methods
Reader Method: timer ((runnable runnable))

automatically generated reader method

Source

runnable.lisp.

Target Slot

timer.

Generic Writer: (setf timer) (object)
Package

noloop.cacau.

Methods
Writer Method: (setf timer) ((runnable runnable))

automatically generated writer method

Source

runnable.lisp.

Target Slot

timer.

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.


Previous: , Up: Internals   [Contents][Index]

6.2.4 Classes

Class: hook-class
Package

noloop.cacau.

Source

hook.lisp.

Direct superclasses

runnable.

Direct methods
Direct slots
Slot: async-p
Initargs

:async-p

Readers

async-p.

Writers

(setf async-p).

Slot: pos-hook-fn
Readers

pos-hook-fn.

Writers

(setf pos-hook-fn).

Class: list-iterator
Package

noloop.cacau.

Source

list-iterator.lisp.

Direct methods
Direct slots
Slot: itens
Initform

(quote nil)

Readers

itens.

Writers

(setf itens).

Slot: current-index
Initform

0

Readers

current-index.

Writers

(setf current-index).

Class: runnable
Package

noloop.cacau.

Source

runnable.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

(setf name).

Slot: fn
Initargs

:fn

Readers

fn.

Writers

(setf fn).

Slot: parent
Initargs

:parent

Readers

parent.

Writers

(setf parent).

Slot: runnable-error
Readers

runnable-error.

Writers

(setf runnable-error).

Slot: eventbus
Initargs

:eventbus

Readers

eventbus.

Writers

(setf eventbus).

Slot: timer
Initform

(noloop.cacau::make-timer)

Readers

timer.

Writers

(setf timer).

Slot: cl-debugger-p
Allocation

:class

Readers

cl-debugger-p.

Writers

(setf cl-debugger-p).

Slot: timeout
Initform

-1

Initargs

:timeout

Readers

timeout.

Writers

(setf timeout).

Class: runner
Package

noloop.cacau.

Source

runner.lisp.

Direct methods
Direct slots
Slot: eventbus
Initform

(noloop.eventbus:make-eventbus)

Readers

eventbus.

Writers

(setf eventbus).

Slot: suite-root
Initargs

:suite-root

Readers

suite-root.

Writers

(setf suite-root).

Slot: abort-p
Readers

abort-p.

Writers

(setf abort-p).

Slot: result
Initform

(make-hash-table)

Readers

result.

Writers

(setf result).

Slot: current-suite
Readers

current-suite.

Writers

(setf current-suite).

Class: suite-class
Package

noloop.cacau.

Source

suite.lisp.

Direct superclasses

runnable.

Direct methods
Direct slots
Slot: suite-before-all
Readers

suite-before-all.

Writers

(setf suite-before-all).

Slot: suite-after-all
Readers

suite-after-all.

Writers

(setf suite-after-all).

Slot: suite-before-each
Readers

suite-before-each.

Writers

(setf suite-before-each).

Slot: suite-after-each
Readers

suite-after-each.

Writers

(setf suite-after-each).

Slot: parents-before-each
Initform

(noloop.cacau::make-list-iterator)

Readers

parents-before-each.

Writers

(setf parents-before-each).

Slot: parents-after-each
Initform

(noloop.cacau::make-list-iterator)

Readers

parents-after-each.

Writers

(setf parents-after-each).

Slot: children
Initform

(noloop.cacau::make-list-iterator)

Readers

children.

Writers

(setf children).

Slot: only-p
Initargs

:only-p

Readers

only-p.

Writers

(setf only-p).

Slot: skip-p
Initargs

:skip-p

Readers

skip-p.

Writers

(setf skip-p).

Class: test-class
Package

noloop.cacau.

Source

test.lisp.

Direct superclasses

runnable.

Direct methods
Direct slots
Slot: async-p
Initargs

:async-p

Readers

async-p.

Writers

(setf async-p).

Slot: only-p
Initargs

:only-p

Readers

only-p.

Writers

(setf only-p).

Slot: skip-p
Initargs

:skip-p

Readers

skip-p.

Writers

(setf skip-p).

Class: timer-class
Package

noloop.cacau.

Source

timer.lisp.

Direct methods
Direct slots
Slot: limit-ms
Initform

-1

Initargs

:limit-ms

Readers

limit-ms.

Writers

(setf limit-ms).

Slot: start-ms
Initform

0

Initargs

:start-ms

Readers

start-ms.

Writers

(setf start-ms).

Slot: end-ms
Initform

0

Readers

end-ms.

Writers

(setf end-ms).

Slot: duration-ms
Initform

0

Readers

duration-ms.

Writers

(setf duration-ms).


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   W  
Index Entry  Section

(
(setf abort-p): Private generic functions
(setf abort-p): Private generic functions
(setf async-p): Private generic functions
(setf async-p): Private generic functions
(setf async-p): Private generic functions
(setf children): Private generic functions
(setf children): Private generic functions
(setf cl-debugger-p): Private generic functions
(setf cl-debugger-p): Private generic functions
(setf current-index): Private generic functions
(setf current-index): Private generic functions
(setf current-suite): Private generic functions
(setf current-suite): Private generic functions
(setf duration-ms): Private generic functions
(setf duration-ms): Private generic functions
(setf end-ms): Private generic functions
(setf end-ms): Private generic functions
(setf eventbus): Private generic functions
(setf eventbus): Private generic functions
(setf eventbus): Private generic functions
(setf fn): Private generic functions
(setf fn): Private generic functions
(setf itens): Private generic functions
(setf itens): Private generic functions
(setf limit-ms): Private generic functions
(setf limit-ms): Private generic functions
(setf name): Private generic functions
(setf name): Private generic functions
(setf only-p): Private generic functions
(setf only-p): Private generic functions
(setf only-p): Private generic functions
(setf parent): Private generic functions
(setf parent): Private generic functions
(setf parents-after-each): Private generic functions
(setf parents-after-each): Private generic functions
(setf parents-before-each): Private generic functions
(setf parents-before-each): Private generic functions
(setf pos-hook-fn): Private generic functions
(setf pos-hook-fn): Private generic functions
(setf result): Public generic functions
(setf result): Public generic functions
(setf runnable-error): Private generic functions
(setf runnable-error): Private generic functions
(setf skip-p): Private generic functions
(setf skip-p): Private generic functions
(setf skip-p): Private generic functions
(setf start-ms): Private generic functions
(setf start-ms): Private generic functions
(setf suite-after-all): Private generic functions
(setf suite-after-all): Private generic functions
(setf suite-after-each): Private generic functions
(setf suite-after-each): Private generic functions
(setf suite-before-all): Private generic functions
(setf suite-before-all): Private generic functions
(setf suite-before-each): Private generic functions
(setf suite-before-each): Private generic functions
(setf suite-root): Public generic functions
(setf suite-root): Public generic functions
(setf timeout): Private generic functions
(setf timeout): Private generic functions
(setf timer): Private generic functions
(setf timer): Private generic functions

A
abort-p: Private generic functions
abort-p: Private generic functions
add: Private generic functions
add: Private generic functions
add-child: Public generic functions
add-child: Public generic functions
after-all: Public ordinary functions
after-each: Public ordinary functions
after-run: Private generic functions
after-run: Private generic functions
after-run: Private generic functions
async-p: Private generic functions
async-p: Private generic functions
async-p: Private generic functions

B
before-all: Public ordinary functions
before-each: Public ordinary functions

C
cacau-logo: Private ordinary functions
cacau-runner: Public ordinary functions
child-by-name: Private generic functions
child-by-name: Private generic functions
children: Private generic functions
children: Private generic functions
cl-debugger: Public ordinary functions
cl-debugger-p: Private generic functions
cl-debugger-p: Private generic functions
collect-after-each-recursive: Private generic functions
collect-after-each-recursive: Private generic functions
collect-before-each-recursive: Private generic functions
collect-before-each-recursive: Private generic functions
common-create-after-all: Public ordinary functions
common-create-after-each: Public ordinary functions
common-create-before-all: Public ordinary functions
common-create-before-each: Public ordinary functions
common-create-suite: Public ordinary functions
common-create-suite-with-parent: Private ordinary functions
common-create-test: Public ordinary functions
cond-options: Private macros
context: Public ordinary functions
count-suites-recursive: Private generic functions
count-suites-recursive: Private generic functions
count-tests-recursive: Private generic functions
count-tests-recursive: Private generic functions
create-after-all: Public generic functions
create-after-all: Public generic functions
create-after-each: Public generic functions
create-after-each: Public generic functions
create-before-all: Public generic functions
create-before-all: Public generic functions
create-before-each: Public generic functions
create-before-each: Public generic functions
create-format-gethash-text-color: Private ordinary functions
create-hash: Private macros
create-list-iterator: Private macros
create-reporter: Private ordinary functions
create-reporter-fn: Private ordinary functions
create-runner-listeners: Private ordinary functions
create-suite: Public generic functions
create-suite: Public generic functions
create-test: Public generic functions
create-test: Public generic functions
current-index: Private generic functions
current-index: Private generic functions
current-item: Private generic functions
current-item: Private generic functions
current-suite: Private generic functions
current-suite: Private generic functions
custom-result: Private ordinary functions

D
defafter-all: Public macros
defafter-each: Public macros
defafter-plan: Public macros
defafter-t: Public macros
defbefore-all: Public macros
defbefore-each: Public macros
defbefore-plan: Public macros
defbefore-t: Public macros
defsuite: Public macros
deft: Public macros
deftest: Public macros
defvar*: Private macros
done-p: Private generic functions
done-p: Private generic functions
done-runnable: Private generic functions
done-runnable: Private generic functions
duration-ms: Private generic functions
duration-ms: Private generic functions

E
empty-p: Private generic functions
empty-p: Private generic functions
end-ms: Private generic functions
end-ms: Private generic functions
end-timer: Private generic functions
end-timer: Private generic functions
epilogue: Private ordinary functions
eventbus: Private generic functions
eventbus: Private generic functions
eventbus: Private generic functions
execute-suites-each: Private generic functions
execute-suites-each: Private generic functions
extrapolated-p: Private generic functions
extrapolated-p: Private generic functions

F
fn: Private generic functions
fn: Private generic functions
full-epilogue: Private ordinary functions
Function, after-all: Public ordinary functions
Function, after-each: Public ordinary functions
Function, before-all: Public ordinary functions
Function, before-each: Public ordinary functions
Function, cacau-logo: Private ordinary functions
Function, cacau-runner: Public ordinary functions
Function, cl-debugger: Public ordinary functions
Function, common-create-after-all: Public ordinary functions
Function, common-create-after-each: Public ordinary functions
Function, common-create-before-all: Public ordinary functions
Function, common-create-before-each: Public ordinary functions
Function, common-create-suite: Public ordinary functions
Function, common-create-suite-with-parent: Private ordinary functions
Function, common-create-test: Public ordinary functions
Function, context: Public ordinary functions
Function, create-format-gethash-text-color: Private ordinary functions
Function, create-reporter: Private ordinary functions
Function, create-reporter-fn: Private ordinary functions
Function, create-runner-listeners: Private ordinary functions
Function, custom-result: Private ordinary functions
Function, epilogue: Private ordinary functions
Function, full-epilogue: Private ordinary functions
Function, has-only-recursive: Private ordinary functions
Function, it: Public ordinary functions
Function, make-hook: Private ordinary functions
Function, make-list-iterator: Private ordinary functions
Function, make-runner: Public ordinary functions
Function, make-suite: Private ordinary functions
Function, make-test: Private ordinary functions
Function, make-timer: Private ordinary functions
Function, read-yes: Private ordinary functions
Function, reporter-full: Private ordinary functions
Function, reporter-list: Private ordinary functions
Function, reporter-min: Private ordinary functions
Function, reset-runner: Public ordinary functions
Function, run: Public ordinary functions
Function, separation-bar: Private ordinary functions
Function, skipped: Private ordinary functions
Function, stack-test-errors: Private ordinary functions
Function, string-ansi-color: Private ordinary functions
Function, string-if-not-string: Private ordinary functions
Function, suite: Public ordinary functions
Function, suite-setup: Public ordinary functions
Function, suite-teardown: Public ordinary functions
Function, suite-tests-list-events: Private ordinary functions
Function, test: Public ordinary functions
Function, test-setup: Public ordinary functions
Function, test-teardown: Public ordinary functions

G
Generic Function, (setf abort-p): Private generic functions
Generic Function, (setf async-p): Private generic functions
Generic Function, (setf children): Private generic functions
Generic Function, (setf cl-debugger-p): Private generic functions
Generic Function, (setf current-index): Private generic functions
Generic Function, (setf current-suite): Private generic functions
Generic Function, (setf duration-ms): Private generic functions
Generic Function, (setf end-ms): Private generic functions
Generic Function, (setf eventbus): Private generic functions
Generic Function, (setf fn): Private generic functions
Generic Function, (setf itens): Private generic functions
Generic Function, (setf limit-ms): Private generic functions
Generic Function, (setf name): Private generic functions
Generic Function, (setf only-p): Private generic functions
Generic Function, (setf parent): Private generic functions
Generic Function, (setf parents-after-each): Private generic functions
Generic Function, (setf parents-before-each): Private generic functions
Generic Function, (setf pos-hook-fn): Private generic functions
Generic Function, (setf result): Public generic functions
Generic Function, (setf runnable-error): Private generic functions
Generic Function, (setf skip-p): Private generic functions
Generic Function, (setf start-ms): Private generic functions
Generic Function, (setf suite-after-all): Private generic functions
Generic Function, (setf suite-after-each): Private generic functions
Generic Function, (setf suite-before-all): Private generic functions
Generic Function, (setf suite-before-each): Private generic functions
Generic Function, (setf suite-root): Public generic functions
Generic Function, (setf timeout): Private generic functions
Generic Function, (setf timer): Private generic functions
Generic Function, abort-p: Private generic functions
Generic Function, add: Private generic functions
Generic Function, add-child: Public generic functions
Generic Function, after-run: Private generic functions
Generic Function, async-p: Private generic functions
Generic Function, child-by-name: Private generic functions
Generic Function, children: Private generic functions
Generic Function, cl-debugger-p: Private generic functions
Generic Function, collect-after-each-recursive: Private generic functions
Generic Function, collect-before-each-recursive: Private generic functions
Generic Function, count-suites-recursive: Private generic functions
Generic Function, count-tests-recursive: Private generic functions
Generic Function, create-after-all: Public generic functions
Generic Function, create-after-each: Public generic functions
Generic Function, create-before-all: Public generic functions
Generic Function, create-before-each: Public generic functions
Generic Function, create-suite: Public generic functions
Generic Function, create-test: Public generic functions
Generic Function, current-index: Private generic functions
Generic Function, current-item: Private generic functions
Generic Function, current-suite: Private generic functions
Generic Function, done-p: Private generic functions
Generic Function, done-runnable: Private generic functions
Generic Function, duration-ms: Private generic functions
Generic Function, empty-p: Private generic functions
Generic Function, end-ms: Private generic functions
Generic Function, end-timer: Private generic functions
Generic Function, eventbus: Private generic functions
Generic Function, execute-suites-each: Private generic functions
Generic Function, extrapolated-p: Private generic functions
Generic Function, fn: Private generic functions
Generic Function, inherit-only-recursive: Private generic functions
Generic Function, inherit-timeout: Private generic functions
Generic Function, init-suite: Private generic functions
Generic Function, itens: Private generic functions
Generic Function, last-p: Private generic functions
Generic Function, limit-ms: Private generic functions
Generic Function, name: Private generic functions
Generic Function, next: Private generic functions
Generic Function, next-child: Private generic functions
Generic Function, on-runner: Public generic functions
Generic Function, once-runner: Public generic functions
Generic Function, only-p: Private generic functions
Generic Function, parent: Private generic functions
Generic Function, parents-after-each: Private generic functions
Generic Function, parents-before-each: Private generic functions
Generic Function, pos-hook-fn: Private generic functions
Generic Function, remove-not-only-children-recursive: Private generic functions
Generic Function, remove-skip-children-recursive: Private generic functions
Generic Function, result: Public generic functions
Generic Function, run-progress: Private generic functions
Generic Function, run-runnable: Private generic functions
Generic Function, run-runner: Public generic functions
Generic Function, runnable-error: Private generic functions
Generic Function, setf-assertion-error: Private generic functions
Generic Function, setf-error: Private generic functions
Generic Function, skip-p: Private generic functions
Generic Function, start-iterator: Private generic functions
Generic Function, start-iterator-reverse: Private generic functions
Generic Function, start-ms: Private generic functions
Generic Function, start-timeout: Private generic functions
Generic Function, start-timer: Private generic functions
Generic Function, suite-after-all: Private generic functions
Generic Function, suite-after-each: Private generic functions
Generic Function, suite-before-all: Private generic functions
Generic Function, suite-before-each: Private generic functions
Generic Function, suite-root: Public generic functions
Generic Function, timeout: Private generic functions
Generic Function, timeout-extrapolated-p: Private generic functions
Generic Function, timer: Private generic functions
Generic Function, try-fn: Private generic functions

H
has-only-recursive: Private ordinary functions

I
in-plan: Public macros
inherit-only-recursive: Private generic functions
inherit-only-recursive: Private generic functions
inherit-timeout: Private generic functions
inherit-timeout: Private generic functions
init-suite: Private generic functions
init-suite: Private generic functions
it: Public ordinary functions
itens: Private generic functions
itens: Private generic functions

L
last-p: Private generic functions
last-p: Private generic functions
limit-ms: Private generic functions
limit-ms: Private generic functions

M
Macro, cond-options: Private macros
Macro, create-hash: Private macros
Macro, create-list-iterator: Private macros
Macro, defafter-all: Public macros
Macro, defafter-each: Public macros
Macro, defafter-plan: Public macros
Macro, defafter-t: Public macros
Macro, defbefore-all: Public macros
Macro, defbefore-each: Public macros
Macro, defbefore-plan: Public macros
Macro, defbefore-t: Public macros
Macro, defsuite: Public macros
Macro, deft: Public macros
Macro, deftest: Public macros
Macro, defvar*: Private macros
Macro, in-plan: Public macros
Macro, setf-hash: Private macros
Macro, with-gensyms: Private macros
make-hook: Private ordinary functions
make-list-iterator: Private ordinary functions
make-runner: Public ordinary functions
make-suite: Private ordinary functions
make-test: Private ordinary functions
make-timer: Private ordinary functions
Method, (setf abort-p): Private generic functions
Method, (setf async-p): Private generic functions
Method, (setf async-p): Private generic functions
Method, (setf children): Private generic functions
Method, (setf cl-debugger-p): Private generic functions
Method, (setf current-index): Private generic functions
Method, (setf current-suite): Private generic functions
Method, (setf duration-ms): Private generic functions
Method, (setf end-ms): Private generic functions
Method, (setf eventbus): Private generic functions
Method, (setf eventbus): Private generic functions
Method, (setf fn): Private generic functions
Method, (setf itens): Private generic functions
Method, (setf limit-ms): Private generic functions
Method, (setf name): Private generic functions
Method, (setf only-p): Private generic functions
Method, (setf only-p): Private generic functions
Method, (setf parent): Private generic functions
Method, (setf parents-after-each): Private generic functions
Method, (setf parents-before-each): Private generic functions
Method, (setf pos-hook-fn): Private generic functions
Method, (setf result): Public generic functions
Method, (setf runnable-error): Private generic functions
Method, (setf skip-p): Private generic functions
Method, (setf skip-p): Private generic functions
Method, (setf start-ms): Private generic functions
Method, (setf suite-after-all): Private generic functions
Method, (setf suite-after-each): Private generic functions
Method, (setf suite-before-all): Private generic functions
Method, (setf suite-before-each): Private generic functions
Method, (setf suite-root): Public generic functions
Method, (setf timeout): Private generic functions
Method, (setf timer): Private generic functions
Method, abort-p: Private generic functions
Method, add: Private generic functions
Method, add-child: Public generic functions
Method, after-run: Private generic functions
Method, after-run: Private generic functions
Method, async-p: Private generic functions
Method, async-p: Private generic functions
Method, child-by-name: Private generic functions
Method, children: Private generic functions
Method, cl-debugger-p: Private generic functions
Method, collect-after-each-recursive: Private generic functions
Method, collect-before-each-recursive: Private generic functions
Method, count-suites-recursive: Private generic functions
Method, count-tests-recursive: Private generic functions
Method, create-after-all: Public generic functions
Method, create-after-each: Public generic functions
Method, create-before-all: Public generic functions
Method, create-before-each: Public generic functions
Method, create-suite: Public generic functions
Method, create-test: Public generic functions
Method, current-index: Private generic functions
Method, current-item: Private generic functions
Method, current-suite: Private generic functions
Method, done-p: Private generic functions
Method, done-runnable: Private generic functions
Method, duration-ms: Private generic functions
Method, empty-p: Private generic functions
Method, end-ms: Private generic functions
Method, end-timer: Private generic functions
Method, eventbus: Private generic functions
Method, eventbus: Private generic functions
Method, execute-suites-each: Private generic functions
Method, extrapolated-p: Private generic functions
Method, fn: Private generic functions
Method, inherit-only-recursive: Private generic functions
Method, inherit-timeout: Private generic functions
Method, init-suite: Private generic functions
Method, itens: Private generic functions
Method, last-p: Private generic functions
Method, limit-ms: Private generic functions
Method, name: Private generic functions
Method, next: Private generic functions
Method, next-child: Private generic functions
Method, on-runner: Public generic functions
Method, once-runner: Public generic functions
Method, only-p: Private generic functions
Method, only-p: Private generic functions
Method, parent: Private generic functions
Method, parents-after-each: Private generic functions
Method, parents-before-each: Private generic functions
Method, pos-hook-fn: Private generic functions
Method, remove-not-only-children-recursive: Private generic functions
Method, remove-skip-children-recursive: Private generic functions
Method, result: Public generic functions
Method, run-progress: Private generic functions
Method, run-runnable: Private generic functions
Method, run-runnable: Private generic functions
Method, run-runnable: Private generic functions
Method, run-runner: Public generic functions
Method, runnable-error: Private generic functions
Method, setf-assertion-error: Private generic functions
Method, setf-error: Private generic functions
Method, skip-p: Private generic functions
Method, skip-p: Private generic functions
Method, start-iterator: Private generic functions
Method, start-iterator-reverse: Private generic functions
Method, start-ms: Private generic functions
Method, start-timeout: Private generic functions
Method, start-timer: Private generic functions
Method, suite-after-all: Private generic functions
Method, suite-after-each: Private generic functions
Method, suite-before-all: Private generic functions
Method, suite-before-each: Private generic functions
Method, suite-root: Public generic functions
Method, timeout: Private generic functions
Method, timeout-extrapolated-p: Private generic functions
Method, timer: Private generic functions
Method, try-fn: Private generic functions

N
name: Private generic functions
name: Private generic functions
next: Private generic functions
next: Private generic functions
next-child: Private generic functions
next-child: Private generic functions

O
on-runner: Public generic functions
on-runner: Public generic functions
once-runner: Public generic functions
once-runner: Public generic functions
only-p: Private generic functions
only-p: Private generic functions
only-p: Private generic functions

P
parent: Private generic functions
parent: Private generic functions
parents-after-each: Private generic functions
parents-after-each: Private generic functions
parents-before-each: Private generic functions
parents-before-each: Private generic functions
pos-hook-fn: Private generic functions
pos-hook-fn: Private generic functions

R
read-yes: Private ordinary functions
remove-not-only-children-recursive: Private generic functions
remove-not-only-children-recursive: Private generic functions
remove-skip-children-recursive: Private generic functions
remove-skip-children-recursive: Private generic functions
reporter-full: Private ordinary functions
reporter-list: Private ordinary functions
reporter-min: Private ordinary functions
reset-runner: Public ordinary functions
result: Public generic functions
result: Public generic functions
run: Public ordinary functions
run-progress: Private generic functions
run-progress: Private generic functions
run-runnable: Private generic functions
run-runnable: Private generic functions
run-runnable: Private generic functions
run-runnable: Private generic functions
run-runner: Public generic functions
run-runner: Public generic functions
runnable-error: Private generic functions
runnable-error: Private generic functions

S
separation-bar: Private ordinary functions
setf-assertion-error: Private generic functions
setf-assertion-error: Private generic functions
setf-error: Private generic functions
setf-error: Private generic functions
setf-hash: Private macros
skip-p: Private generic functions
skip-p: Private generic functions
skip-p: Private generic functions
skipped: Private ordinary functions
stack-test-errors: Private ordinary functions
start-iterator: Private generic functions
start-iterator: Private generic functions
start-iterator-reverse: Private generic functions
start-iterator-reverse: Private generic functions
start-ms: Private generic functions
start-ms: Private generic functions
start-timeout: Private generic functions
start-timeout: Private generic functions
start-timer: Private generic functions
start-timer: Private generic functions
string-ansi-color: Private ordinary functions
string-if-not-string: Private ordinary functions
suite: Public ordinary functions
suite-after-all: Private generic functions
suite-after-all: Private generic functions
suite-after-each: Private generic functions
suite-after-each: Private generic functions
suite-before-all: Private generic functions
suite-before-all: Private generic functions
suite-before-each: Private generic functions
suite-before-each: Private generic functions
suite-root: Public generic functions
suite-root: Public generic functions
suite-setup: Public ordinary functions
suite-teardown: Public ordinary functions
suite-tests-list-events: Private ordinary functions

T
test: Public ordinary functions
test-setup: Public ordinary functions
test-teardown: Public ordinary functions
timeout: Private generic functions
timeout: Private generic functions
timeout-extrapolated-p: Private generic functions
timeout-extrapolated-p: Private generic functions
timer: Private generic functions
timer: Private generic functions
try-fn: Private generic functions
try-fn: Private generic functions

W
with-gensyms: Private macros

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   A   C   D   E   F   I   L   N   O   P   R   S   T  
Index Entry  Section

A
abort-p: Private classes
async-p: Private classes
async-p: Private classes

C
children: Private classes
cl-debugger-p: Private classes
current-index: Private classes
current-suite: Private classes

D
duration-ms: Private classes

E
end-ms: Private classes
eventbus: Private classes
eventbus: Private classes

F
fn: Private classes

I
itens: Private classes

L
limit-ms: Private classes

N
name: Private classes

O
only-p: Private classes
only-p: Private classes

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

R
result: Private classes
runnable-error: Private classes

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

T
timeout: Private classes
timer: Private classes

Jump to:   A   C   D   E   F   I   L   N   O   P   R   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   F   H   I   K   L   M   N   P   R   S   T   U  
Index Entry  Section

B
base.lisp: The cacau/src/reporters/base․lisp file
bdd.lisp: The cacau/src/interfaces/bdd․lisp file

C
cacau: The cacau system
cacau.asd: The cacau/cacau․asd file
cacau.lisp: The cacau/src/cacau․lisp file
cl.lisp: The cacau/src/interfaces/cl․lisp file
Class, hook-class: Private classes
Class, list-iterator: Private classes
Class, runnable: Private classes
Class, runner: Private classes
Class, suite-class: Private classes
Class, test-class: Private classes
Class, timer-class: Private classes
common.lisp: The cacau/src/interfaces/common․lisp file

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

H
hook-class: Private classes
hook.lisp: The cacau/src/kernel/hook․lisp file

I
interfaces: The cacau/src/interfaces module

K
kernel: The cacau/src/kernel module

L
list-iterator: Private classes
list-iterator.lisp: The cacau/src/kernel/list-iterator․lisp file
list.lisp: The cacau/src/reporters/list․lisp file

M
min.lisp: The cacau/src/reporters/min․lisp file
Module, interfaces: The cacau/src/interfaces module
Module, kernel: The cacau/src/kernel module
Module, reporters: The cacau/src/reporters module
Module, src: The cacau/src module

N
no-spaghetti.lisp: The cacau/src/interfaces/no-spaghetti․lisp file
noloop.cacau: The noloop․cacau package

P
Package, noloop.cacau: The noloop․cacau package
package.lisp: The cacau/src/package․lisp file

R
reporters: The cacau/src/reporters module
runnable: Private classes
runnable.lisp: The cacau/src/kernel/runnable․lisp file
runner: Private classes
runner-listeners.lisp: The cacau/src/kernel/runner-listeners․lisp file
runner.lisp: The cacau/src/kernel/runner․lisp file

S
src: The cacau/src module
suite-class: Private classes
suite.lisp: The cacau/src/kernel/suite․lisp file
System, cacau: The cacau system

T
tdd.lisp: The cacau/src/interfaces/tdd․lisp file
test-class: Private classes
test.lisp: The cacau/src/kernel/test․lisp file
timer-class: Private classes
timer.lisp: The cacau/src/kernel/timer․lisp file

U
utils.lisp: The cacau/src/utils․lisp file

Jump to:   B   C   F   H   I   K   L   M   N   P   R   S   T   U