The cacau Reference Manual

Table of Contents

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 3.0 "Montgomery Scott" on Mon Dec 02 09:09:10 2019 GMT+0.


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

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


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

2 Systems

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


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

2.1 cacau

Maintainer

noloop <noloop@zoho.com>

Author

noloop <noloop@zoho.com>

Home Page

https://github.com/noloop/cacau

Source Control

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

Bug Tracker

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

License

GPLv3

Description

Test Runner in Common Lisp.

Version

1.0.0

Dependencies
Source

cacau.asd (file)

Component

src (module)


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

3 Modules

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


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

3.1 cacau/src

Parent

cacau (system)

Location

src/

Components

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

3.2 cacau/src/kernel

Parent

src (module)

Location

src/kernel/

Components

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

3.3 cacau/src/reporters

Parent

src (module)

Location

src/reporters/

Components

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

3.4 cacau/src/interfaces

Parent

src (module)

Location

src/interfaces/

Components

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

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 files   [Contents][Index]

4.1.1 cacau.asd

Location

cacau.asd

Systems

cacau (system)


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

4.1.2 cacau/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

noloop.cacau


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

4.1.3 cacau/src/utils.lisp

Parent

src (module)

Location

src/utils.lisp

Internal Definitions

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

4.1.4 cacau/src/kernel/timer.lisp

Parent

kernel (module)

Location

src/kernel/timer.lisp

Internal Definitions

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

4.1.5 cacau/src/kernel/runnable.lisp

Parent

kernel (module)

Location

src/kernel/runnable.lisp

Internal Definitions

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

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

Parent

kernel (module)

Location

src/kernel/list-iterator.lisp

Internal Definitions

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

4.1.7 cacau/src/kernel/test.lisp

Parent

kernel (module)

Location

src/kernel/test.lisp

Internal Definitions

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

4.1.8 cacau/src/kernel/hook.lisp

Parent

kernel (module)

Location

src/kernel/hook.lisp

Internal Definitions

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

4.1.9 cacau/src/kernel/suite.lisp

Parent

kernel (module)

Location

src/kernel/suite.lisp

Exported Definitions
Internal Definitions

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

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

Parent

kernel (module)

Location

src/kernel/runner-listeners.lisp

Internal Definitions

create-runner-listeners (function)


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

4.1.11 cacau/src/kernel/runner.lisp

Parent

kernel (module)

Location

src/kernel/runner.lisp

Exported Definitions
Internal Definitions

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

4.1.12 cacau/src/reporters/base.lisp

Parent

reporters (module)

Location

src/reporters/base.lisp

Internal Definitions

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

4.1.13 cacau/src/reporters/min.lisp

Parent

reporters (module)

Location

src/reporters/min.lisp

Internal Definitions

reporter-min (function)


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

4.1.14 cacau/src/reporters/list.lisp

Parent

reporters (module)

Location

src/reporters/list.lisp

Internal Definitions

reporter-list (function)


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

4.1.15 cacau/src/reporters/full.lisp

Parent

reporters (module)

Location

src/reporters/full.lisp

Internal Definitions

reporter-full (function)


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

4.1.16 cacau/src/cacau.lisp

Parent

src (module)

Location

src/cacau.lisp

Exported Definitions
Internal Definitions

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

4.1.17 cacau/src/interfaces/common.lisp

Parent

interfaces (module)

Location

src/interfaces/common.lisp

Exported Definitions
Internal Definitions

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

4.1.18 cacau/src/interfaces/cl.lisp

Parent

interfaces (module)

Location

src/interfaces/cl.lisp

Exported Definitions

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

4.1.19 cacau/src/interfaces/bdd.lisp

Parent

interfaces (module)

Location

src/interfaces/bdd.lisp

Exported Definitions

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

4.1.20 cacau/src/interfaces/tdd.lisp

Parent

interfaces (module)

Location

src/interfaces/tdd.lisp

Exported Definitions

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

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

Parent

interfaces (module)

Location

src/interfaces/no-spaghetti.lisp

Exported Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 noloop.cacau

Source

package.lisp (file)

Nickname

cacau

Use List

common-lisp

Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Macros

Macro: defafter-all NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: defafter-each NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: defafter-plan NAME OPTIONS &body BODY
Package

noloop.cacau

Source

no-spaghetti.lisp (file)

Macro: defafter-t NAME OPTIONS &body BODY
Package

noloop.cacau

Source

no-spaghetti.lisp (file)

Macro: defbefore-all NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: defbefore-each NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: defbefore-plan NAME OPTIONS &body BODY
Package

noloop.cacau

Source

no-spaghetti.lisp (file)

Macro: defbefore-t NAME OPTIONS &body BODY
Package

noloop.cacau

Source

no-spaghetti.lisp (file)

Macro: defsuite NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: deft NAME OPTIONS &body BODY
Package

noloop.cacau

Source

no-spaghetti.lisp (file)

Macro: deftest NAME OPTIONS &body BODY
Package

noloop.cacau

Source

cl.lisp (file)

Macro: in-plan NAME &optional OPTIONS
Package

noloop.cacau

Source

no-spaghetti.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Functions

Function: after-all NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: after-each NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: before-all NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: before-each NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: cacau-runner ()
Package

noloop.cacau

Source

cacau.lisp (file)

Function: cl-debugger OBJ-RUNNABLE ON-OFF

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

Package

noloop.cacau

Source

cacau.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

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

noloop.cacau

Source

common.lisp (file)

Function: context NAME FN &key ONLY SKIP TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: it NAME FN &key ASYNC ONLY SKIP TIMEOUT
Package

noloop.cacau

Source

bdd.lisp (file)

Function: make-runner ()
Package

noloop.cacau

Source

runner.lisp (file)

Function: reset-runner ()
Package

noloop.cacau

Source

cacau.lisp (file)

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

noloop.cacau

Source

cacau.lisp (file)

Function: suite NAME FN &key ONLY SKIP TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)

Function: suite-setup NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)

Function: suite-teardown NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)

Function: test NAME FN &key ASYNC ONLY SKIP TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)

Function: test-setup NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)

Function: test-teardown NAME FN &key ASYNC TIMEOUT
Package

noloop.cacau

Source

tdd.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Generic functions

Generic Function: add-child SUITE CHILD
Package

noloop.cacau

Methods
Method: add-child (SUITE suite-class) CHILD
Source

suite.lisp (file)

Generic Function: create-after-all SUITE NAME FN &key ASYNC-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-after-all (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
Source

suite.lisp (file)

Generic Function: create-after-each SUITE NAME FN &key ASYNC-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-after-each (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
Source

suite.lisp (file)

Generic Function: create-before-all SUITE NAME FN &key ASYNC-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-before-all (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
Source

suite.lisp (file)

Generic Function: create-before-each SUITE NAME FN &key ASYNC-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-before-each (SUITE suite-class) NAME FN &key ASYNC-P TIMEOUT
Source

suite.lisp (file)

Generic Function: create-suite OBJ NAME &key ONLY-P SKIP-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-suite (OBJ runner) NAME &key ONLY-P SKIP-P TIMEOUT
Source

runner.lisp (file)

Generic Function: create-test OBJ NAME FN &key ASYNC-P ONLY-P SKIP-P TIMEOUT
Package

noloop.cacau

Methods
Method: create-test (OBJ runner) NAME FN &key ASYNC-P ONLY-P SKIP-P TIMEOUT
Source

runner.lisp (file)

Generic Function: on-runner OBJ EVENT-NAME FN
Package

noloop.cacau

Methods
Method: on-runner (OBJ runner) EVENT-NAME FN
Source

runner.lisp (file)

Generic Function: once-runner OBJ EVENT-NAME FN
Package

noloop.cacau

Methods
Method: once-runner (OBJ runner) EVENT-NAME FN
Source

runner.lisp (file)

Generic Function: result OBJECT
Generic Function: (setf result) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: result (RUNNER runner)

automatically generated reader method

Source

runner.lisp (file)

Method: (setf result) NEW-VALUE (RUNNER runner)

automatically generated writer method

Source

runner.lisp (file)

Generic Function: run-runner OBJ
Package

noloop.cacau

Methods
Method: run-runner (OBJ runner)
Source

runner.lisp (file)

Generic Function: suite-root OBJECT
Generic Function: (setf suite-root) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: suite-root (RUNNER runner)

automatically generated reader method

Source

runner.lisp (file)

Method: (setf suite-root) NEW-VALUE (RUNNER runner)

automatically generated writer method

Source

runner.lisp (file)


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

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Macros

Macro: cond-options OPTIONS &body BODY
Package

noloop.cacau

Source

common.lisp (file)

Macro: create-hash &rest FIELDS

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

Package

noloop.cacau

Source

utils.lisp (file)

Macro: create-list-iterator NEW-LIST

Creates a new lambda that returns the next item in the new-list reverted. Returns nil if there is not the next item in the list. Example: (let* ((itens ’(1 2))
(next-item (create-list-iterator itens)))
(print (funcall next-item))
(print (funcall next-item))
(print (funcall next-item)))
=>
1
2
NIL

Package

noloop.cacau

Source

utils.lisp (file)

Macro: defvar* BINDINGS
Package

noloop.cacau

Source

utils.lisp (file)

Macro: setf-hash HASH &rest FIELDS

Example: (let ((hash (make-hash-table :test ’eq))) (setf-hash hash ’((:a 1) (:b 2)))
hash)

Package

noloop.cacau

Source

utils.lisp (file)

Macro: with-gensyms VARS &body BODY
Package

noloop.cacau

Source

utils.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Package

noloop.cacau

Source

base.lisp (file)

Function: common-create-suite-with-parent NAME &key ONLY-P SKIP-P TIMEOUT PARENT
Package

noloop.cacau

Source

common.lisp (file)

Function: create-format-gethash-text-color RUNNER-RESULT
Package

noloop.cacau

Source

base.lisp (file)

Function: create-reporter RUNNER NAME REPORTER-OPTIONS
Package

noloop.cacau

Source

cacau.lisp (file)

Function: create-reporter-fn OLD-RUNNER COLORFUL REPORTER REPORTER-OPTIONS
Package

noloop.cacau

Source

cacau.lisp (file)

Function: create-runner-listeners RUNNER
Package

noloop.cacau

Source

runner-listeners.lisp (file)

Function: custom-result RUNNER-RESULT OPTIONS
Package

noloop.cacau

Source

base.lisp (file)

Function: epilogue RUNNER-RESULT
Package

noloop.cacau

Source

base.lisp (file)

Function: full-epilogue RUNNER-RESULT OPTIONS
Package

noloop.cacau

Source

base.lisp (file)

Function: has-only-recursive OBJ
Package

noloop.cacau

Source

suite.lisp (file)

Function: make-hook &key NAME FN ASYNC-P TIMEOUT EVENTBUS
Package

noloop.cacau

Source

hook.lisp (file)

Function: make-list-iterator ()
Package

noloop.cacau

Source

list-iterator.lisp (file)

Function: make-suite &key NAME PARENT ONLY-P SKIP-P TIMEOUT EVENTBUS
Package

noloop.cacau

Source

suite.lisp (file)

Function: make-test &key NAME FN ASYNC-P ONLY-P SKIP-P TIMEOUT EVENTBUS
Package

noloop.cacau

Source

test.lisp (file)

Function: make-timer ()
Package

noloop.cacau

Source

timer.lisp (file)

Function: read-yes ()
Package

noloop.cacau

Source

utils.lisp (file)

Function: reporter-full RUNNER OPTIONS
Package

noloop.cacau

Source

full.lisp (file)

Function: reporter-list RUNNER OPTIONS
Package

noloop.cacau

Source

list.lisp (file)

Function: reporter-min RUNNER OPTIONS
Package

noloop.cacau

Source

min.lisp (file)

Function: separation-bar &optional COLOR
Package

noloop.cacau

Source

base.lisp (file)

Function: skipped RUNNER-RESULT
Package

noloop.cacau

Source

base.lisp (file)

Function: stack-test-errors RUNNER-RESULT &key REVERSE-LIST
Package

noloop.cacau

Source

base.lisp (file)

Function: string-ansi-color STG COLOR &key STYLE BACKGROUND
Package

noloop.cacau

Source

utils.lisp (file)

Function: string-if-not-string VALUE
Package

noloop.cacau

Source

utils.lisp (file)

Function: suite-tests-list-events RUNNER
Package

noloop.cacau

Source

base.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Generic functions

Generic Function: abort-p OBJECT
Generic Function: (setf abort-p) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: abort-p (RUNNER runner)

automatically generated reader method

Source

runner.lisp (file)

Method: (setf abort-p) NEW-VALUE (RUNNER runner)

automatically generated writer method

Source

runner.lisp (file)

Generic Function: add OBJ ITEM
Package

noloop.cacau

Methods
Method: add (OBJ list-iterator) ITEM
Source

list-iterator.lisp (file)

Generic Function: after-run OBJ

Something must be run after run-runnable.

Package

noloop.cacau

Source

runnable.lisp (file)

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

hook.lisp (file)

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

test.lisp (file)

Generic Function: async-p OBJECT
Generic Function: (setf async-p) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: async-p (HOOK-CLASS hook-class)

automatically generated reader method

Source

hook.lisp (file)

Method: (setf async-p) NEW-VALUE (HOOK-CLASS hook-class)

automatically generated writer method

Source

hook.lisp (file)

Method: async-p (TEST-CLASS test-class)

automatically generated reader method

Source

test.lisp (file)

Method: (setf async-p) NEW-VALUE (TEST-CLASS test-class)

automatically generated writer method

Source

test.lisp (file)

Generic Function: child-by-name SUITE PARENT-NAME
Package

noloop.cacau

Methods
Method: child-by-name (SUITE suite-class) PARENT-NAME
Source

suite.lisp (file)

Generic Function: children OBJECT
Generic Function: (setf children) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: children (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf children) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: cl-debugger-p OBJECT
Generic Function: (setf cl-debugger-p) NEW-VALUE OBJECT
Package

noloop.cacau

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

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf cl-debugger-p) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: collect-after-each-recursive SUITE PARENTS-EACH
Package

noloop.cacau

Methods
Method: collect-after-each-recursive (SUITE suite-class) PARENTS-EACH
Source

suite.lisp (file)

Generic Function: collect-before-each-recursive SUITE PARENTS-EACH
Package

noloop.cacau

Methods
Method: collect-before-each-recursive (SUITE suite-class) PARENTS-EACH
Source

suite.lisp (file)

Generic Function: count-suites-recursive LIST
Package

noloop.cacau

Methods
Method: count-suites-recursive LIST
Source

suite.lisp (file)

Generic Function: count-tests-recursive LIST
Package

noloop.cacau

Methods
Method: count-tests-recursive LIST
Source

suite.lisp (file)

Generic Function: current-index OBJECT
Generic Function: (setf current-index) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: current-index (LIST-ITERATOR list-iterator)

automatically generated reader method

Source

list-iterator.lisp (file)

Method: (setf current-index) NEW-VALUE (LIST-ITERATOR list-iterator)

automatically generated writer method

Source

list-iterator.lisp (file)

Generic Function: current-item OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: current-suite OBJECT
Generic Function: (setf current-suite) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: current-suite (RUNNER runner)

automatically generated reader method

Source

runner.lisp (file)

Method: (setf current-suite) NEW-VALUE (RUNNER runner)

automatically generated writer method

Source

runner.lisp (file)

Generic Function: done-p OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: done-runnable OBJ
Package

noloop.cacau

Methods
Method: done-runnable (OBJ runnable)
Source

runnable.lisp (file)

Generic Function: duration-ms OBJECT
Generic Function: (setf duration-ms) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: duration-ms (TIMER-CLASS timer-class)

automatically generated reader method

Source

timer.lisp (file)

Method: (setf duration-ms) NEW-VALUE (TIMER-CLASS timer-class)

automatically generated writer method

Source

timer.lisp (file)

Generic Function: empty-p OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: end-ms OBJECT
Generic Function: (setf end-ms) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: end-ms (TIMER-CLASS timer-class)

automatically generated reader method

Source

timer.lisp (file)

Method: (setf end-ms) NEW-VALUE (TIMER-CLASS timer-class)

automatically generated writer method

Source

timer.lisp (file)

Generic Function: end-timer OBJ
Package

noloop.cacau

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

timer.lisp (file)

Generic Function: eventbus OBJECT
Generic Function: (setf eventbus) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: eventbus (RUNNER runner)

automatically generated reader method

Source

runner.lisp (file)

Method: (setf eventbus) NEW-VALUE (RUNNER runner)

automatically generated writer method

Source

runner.lisp (file)

Method: eventbus (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf eventbus) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: execute-suites-each SUITE PARENTS-EACH AFTER-HOOK-FN
Package

noloop.cacau

Methods
Method: execute-suites-each (SUITE suite-class) PARENTS-EACH AFTER-HOOK-FN
Source

suite.lisp (file)

Generic Function: extrapolated-p OBJ
Package

noloop.cacau

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

timer.lisp (file)

Generic Function: fn OBJECT
Generic Function: (setf fn) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: fn (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf fn) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: inherit-only-recursive SUITE
Package

noloop.cacau

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

suite.lisp (file)

Generic Function: inherit-timeout OBJ
Package

noloop.cacau

Methods
Method: inherit-timeout (OBJ runnable)
Source

runnable.lisp (file)

Generic Function: init-suite SUITE
Package

noloop.cacau

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

suite.lisp (file)

Generic Function: itens OBJECT
Generic Function: (setf itens) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: itens (LIST-ITERATOR list-iterator)

automatically generated reader method

Source

list-iterator.lisp (file)

Method: (setf itens) NEW-VALUE (LIST-ITERATOR list-iterator)

automatically generated writer method

Source

list-iterator.lisp (file)

Generic Function: last-p OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: limit-ms OBJECT
Generic Function: (setf limit-ms) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: limit-ms (TIMER-CLASS timer-class)

automatically generated reader method

Source

timer.lisp (file)

Method: (setf limit-ms) NEW-VALUE (TIMER-CLASS timer-class)

automatically generated writer method

Source

timer.lisp (file)

Generic Function: name OBJECT
Generic Function: (setf name) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: name (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf name) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: next OBJ
Package

noloop.cacau

Methods
Method: next (OBJ list-iterator)
Source

list-iterator.lisp (file)

Generic Function: next-child SUITE
Package

noloop.cacau

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

suite.lisp (file)

Generic Function: only-p OBJECT
Generic Function: (setf only-p) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: only-p (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf only-p) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Method: only-p (TEST-CLASS test-class)

automatically generated reader method

Source

test.lisp (file)

Method: (setf only-p) NEW-VALUE (TEST-CLASS test-class)

automatically generated writer method

Source

test.lisp (file)

Generic Function: parent OBJECT
Generic Function: (setf parent) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: parent (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf parent) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: parents-after-each OBJECT
Generic Function: (setf parents-after-each) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: parents-after-each (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf parents-after-each) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: parents-before-each OBJECT
Generic Function: (setf parents-before-each) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: parents-before-each (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf parents-before-each) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: pos-hook-fn OBJECT
Generic Function: (setf pos-hook-fn) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: pos-hook-fn (HOOK-CLASS hook-class)

automatically generated reader method

Source

hook.lisp (file)

Method: (setf pos-hook-fn) NEW-VALUE (HOOK-CLASS hook-class)

automatically generated writer method

Source

hook.lisp (file)

Generic Function: remove-not-only-children-recursive SUITE
Package

noloop.cacau

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

suite.lisp (file)

Generic Function: remove-skip-children-recursive SUITE
Package

noloop.cacau

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

suite.lisp (file)

Generic Function: run-progress OBJ
Package

noloop.cacau

Methods
Method: run-progress (OBJ runner)
Source

runner.lisp (file)

Generic Function: run-runnable OBJ &optional FN

Something must be run, such as a test suite that calls run-runnable from each tests, or running a hook.

Package

noloop.cacau

Source

runnable.lisp (file)

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

suite.lisp (file)

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

hook.lisp (file)

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

test.lisp (file)

Generic Function: runnable-error OBJECT
Generic Function: (setf runnable-error) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: runnable-error (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf runnable-error) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: setf-assertion-error OBJ C
Package

noloop.cacau

Methods
Method: setf-assertion-error (OBJ runnable) C
Source

runnable.lisp (file)

Generic Function: setf-error OBJ ERROR-MSG
Package

noloop.cacau

Methods
Method: setf-error (OBJ runnable) ERROR-MSG
Source

runnable.lisp (file)

Generic Function: skip-p OBJECT
Generic Function: (setf skip-p) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: skip-p (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf skip-p) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Method: skip-p (TEST-CLASS test-class)

automatically generated reader method

Source

test.lisp (file)

Method: (setf skip-p) NEW-VALUE (TEST-CLASS test-class)

automatically generated writer method

Source

test.lisp (file)

Generic Function: start-iterator OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: start-iterator-reverse OBJ
Package

noloop.cacau

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

list-iterator.lisp (file)

Generic Function: start-ms OBJECT
Generic Function: (setf start-ms) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: start-ms (TIMER-CLASS timer-class)

automatically generated reader method

Source

timer.lisp (file)

Method: (setf start-ms) NEW-VALUE (TIMER-CLASS timer-class)

automatically generated writer method

Source

timer.lisp (file)

Generic Function: start-timeout OBJ
Package

noloop.cacau

Methods
Method: start-timeout (OBJ runnable)
Source

runnable.lisp (file)

Generic Function: start-timer OBJ
Package

noloop.cacau

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

timer.lisp (file)

Generic Function: suite-after-all OBJECT
Generic Function: (setf suite-after-all) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: suite-after-all (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf suite-after-all) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: suite-after-each OBJECT
Generic Function: (setf suite-after-each) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: suite-after-each (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf suite-after-each) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: suite-before-all OBJECT
Generic Function: (setf suite-before-all) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: suite-before-all (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf suite-before-all) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: suite-before-each OBJECT
Generic Function: (setf suite-before-each) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: suite-before-each (SUITE-CLASS suite-class)

automatically generated reader method

Source

suite.lisp (file)

Method: (setf suite-before-each) NEW-VALUE (SUITE-CLASS suite-class)

automatically generated writer method

Source

suite.lisp (file)

Generic Function: timeout OBJECT
Generic Function: (setf timeout) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: timeout (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf timeout) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: timeout-extrapolated-p OBJ
Package

noloop.cacau

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

runnable.lisp (file)

Generic Function: timer OBJECT
Generic Function: (setf timer) NEW-VALUE OBJECT
Package

noloop.cacau

Methods
Method: timer (RUNNABLE runnable)

automatically generated reader method

Source

runnable.lisp (file)

Method: (setf timer) NEW-VALUE (RUNNABLE runnable)

automatically generated writer method

Source

runnable.lisp (file)

Generic Function: try-fn OBJ TRY &key AFTER-ERROR-FN
Package

noloop.cacau

Methods
Method: try-fn (OBJ runnable) TRY &key AFTER-ERROR-FN
Source

runnable.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Classes

Class: hook-class ()
Package

noloop.cacau

Source

hook.lisp (file)

Direct superclasses

runnable (class)

Direct methods
Direct slots
Slot: async-p
Initargs

:async-p

Readers

async-p (generic function)

Writers

(setf async-p) (generic function)

Slot: pos-hook-fn
Readers

pos-hook-fn (generic function)

Writers

(setf pos-hook-fn) (generic function)

Class: list-iterator ()
Package

noloop.cacau

Source

list-iterator.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: itens
Initform

(quote nil)

Readers

itens (generic function)

Writers

(setf itens) (generic function)

Slot: current-index
Initform

0

Readers

current-index (generic function)

Writers

(setf current-index) (generic function)

Class: runnable ()
Package

noloop.cacau

Source

runnable.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Writers

(setf name) (generic function)

Slot: fn
Initargs

:fn

Readers

fn (generic function)

Writers

(setf fn) (generic function)

Slot: parent
Initargs

:parent

Readers

parent (generic function)

Writers

(setf parent) (generic function)

Slot: runnable-error
Readers

runnable-error (generic function)

Writers

(setf runnable-error) (generic function)

Slot: eventbus
Initargs

:eventbus

Readers

eventbus (generic function)

Writers

(setf eventbus) (generic function)

Slot: timer
Initform

(noloop.cacau::make-timer)

Readers

timer (generic function)

Writers

(setf timer) (generic function)

Slot: cl-debugger-p
Allocation

:class

Readers

cl-debugger-p (generic function)

Writers

(setf cl-debugger-p) (generic function)

Slot: timeout
Initargs

:timeout

Initform

-1

Readers

timeout (generic function)

Writers

(setf timeout) (generic function)

Class: runner ()
Package

noloop.cacau

Source

runner.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: eventbus
Initform

(noloop.eventbus:make-eventbus)

Readers

eventbus (generic function)

Writers

(setf eventbus) (generic function)

Slot: suite-root
Initargs

:suite-root

Readers

suite-root (generic function)

Writers

(setf suite-root) (generic function)

Slot: abort-p
Readers

abort-p (generic function)

Writers

(setf abort-p) (generic function)

Slot: result
Initform

(make-hash-table)

Readers

result (generic function)

Writers

(setf result) (generic function)

Slot: current-suite
Readers

current-suite (generic function)

Writers

(setf current-suite) (generic function)

Class: suite-class ()
Package

noloop.cacau

Source

suite.lisp (file)

Direct superclasses

runnable (class)

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

suite-before-all (generic function)

Writers

(setf suite-before-all) (generic function)

Slot: suite-after-all
Readers

suite-after-all (generic function)

Writers

(setf suite-after-all) (generic function)

Slot: suite-before-each
Readers

suite-before-each (generic function)

Writers

(setf suite-before-each) (generic function)

Slot: suite-after-each
Readers

suite-after-each (generic function)

Writers

(setf suite-after-each) (generic function)

Slot: parents-before-each
Initform

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

Readers

parents-before-each (generic function)

Writers

(setf parents-before-each) (generic function)

Slot: parents-after-each
Initform

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

Readers

parents-after-each (generic function)

Writers

(setf parents-after-each) (generic function)

Slot: children
Initform

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

Readers

children (generic function)

Writers

(setf children) (generic function)

Slot: only-p
Initargs

:only-p

Readers

only-p (generic function)

Writers

(setf only-p) (generic function)

Slot: skip-p
Initargs

:skip-p

Readers

skip-p (generic function)

Writers

(setf skip-p) (generic function)

Class: test-class ()
Package

noloop.cacau

Source

test.lisp (file)

Direct superclasses

runnable (class)

Direct methods
Direct slots
Slot: async-p
Initargs

:async-p

Readers

async-p (generic function)

Writers

(setf async-p) (generic function)

Slot: only-p
Initargs

:only-p

Readers

only-p (generic function)

Writers

(setf only-p) (generic function)

Slot: skip-p
Initargs

:skip-p

Readers

skip-p (generic function)

Writers

(setf skip-p) (generic function)

Class: timer-class ()
Package

noloop.cacau

Source

timer.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: limit-ms
Initargs

:limit-ms

Initform

-1

Readers

limit-ms (generic function)

Writers

(setf limit-ms) (generic function)

Slot: start-ms
Initargs

:start-ms

Initform

0

Readers

start-ms (generic function)

Writers

(setf start-ms) (generic function)

Slot: end-ms
Initform

0

Readers

end-ms (generic function)

Writers

(setf end-ms) (generic function)

Slot: duration-ms
Initform

0

Readers

duration-ms (generic function)

Writers

(setf duration-ms) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

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

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

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

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

Jump to:   C   F   L   M  

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): Internal generic functions
(setf abort-p): Internal generic functions
(setf async-p): Internal generic functions
(setf async-p): Internal generic functions
(setf async-p): Internal generic functions
(setf children): Internal generic functions
(setf children): Internal generic functions
(setf cl-debugger-p): Internal generic functions
(setf cl-debugger-p): Internal generic functions
(setf current-index): Internal generic functions
(setf current-index): Internal generic functions
(setf current-suite): Internal generic functions
(setf current-suite): Internal generic functions
(setf duration-ms): Internal generic functions
(setf duration-ms): Internal generic functions
(setf end-ms): Internal generic functions
(setf end-ms): Internal generic functions
(setf eventbus): Internal generic functions
(setf eventbus): Internal generic functions
(setf eventbus): Internal generic functions
(setf fn): Internal generic functions
(setf fn): Internal generic functions
(setf itens): Internal generic functions
(setf itens): Internal generic functions
(setf limit-ms): Internal generic functions
(setf limit-ms): Internal generic functions
(setf name): Internal generic functions
(setf name): Internal generic functions
(setf only-p): Internal generic functions
(setf only-p): Internal generic functions
(setf only-p): Internal generic functions
(setf parent): Internal generic functions
(setf parent): Internal generic functions
(setf parents-after-each): Internal generic functions
(setf parents-after-each): Internal generic functions
(setf parents-before-each): Internal generic functions
(setf parents-before-each): Internal generic functions
(setf pos-hook-fn): Internal generic functions
(setf pos-hook-fn): Internal generic functions
(setf result): Exported generic functions
(setf result): Exported generic functions
(setf runnable-error): Internal generic functions
(setf runnable-error): Internal generic functions
(setf skip-p): Internal generic functions
(setf skip-p): Internal generic functions
(setf skip-p): Internal generic functions
(setf start-ms): Internal generic functions
(setf start-ms): Internal generic functions
(setf suite-after-all): Internal generic functions
(setf suite-after-all): Internal generic functions
(setf suite-after-each): Internal generic functions
(setf suite-after-each): Internal generic functions
(setf suite-before-all): Internal generic functions
(setf suite-before-all): Internal generic functions
(setf suite-before-each): Internal generic functions
(setf suite-before-each): Internal generic functions
(setf suite-root): Exported generic functions
(setf suite-root): Exported generic functions
(setf timeout): Internal generic functions
(setf timeout): Internal generic functions
(setf timer): Internal generic functions
(setf timer): Internal generic functions

A
abort-p: Internal generic functions
abort-p: Internal generic functions
add: Internal generic functions
add: Internal generic functions
add-child: Exported generic functions
add-child: Exported generic functions
after-all: Exported functions
after-each: Exported functions
after-run: Internal generic functions
after-run: Internal generic functions
after-run: Internal generic functions
async-p: Internal generic functions
async-p: Internal generic functions
async-p: Internal generic functions

B
before-all: Exported functions
before-each: Exported functions

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

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

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

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

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

H
has-only-recursive: Internal functions

I
in-plan: Exported macros
inherit-only-recursive: Internal generic functions
inherit-only-recursive: Internal generic functions
inherit-timeout: Internal generic functions
inherit-timeout: Internal generic functions
init-suite: Internal generic functions
init-suite: Internal generic functions
it: Exported functions
itens: Internal generic functions
itens: Internal generic functions

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

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

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

O
on-runner: Exported generic functions
on-runner: Exported generic functions
once-runner: Exported generic functions
once-runner: Exported generic functions
only-p: Internal generic functions
only-p: Internal generic functions
only-p: Internal generic functions

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

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

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

T
test: Exported functions
test-setup: Exported functions
test-teardown: Exported functions
timeout: Internal generic functions
timeout: Internal generic functions
timeout-extrapolated-p: Internal generic functions
timeout-extrapolated-p: Internal generic functions
timer: Internal generic functions
timer: Internal generic functions
try-fn: Internal generic functions
try-fn: Internal generic functions

W
with-gensyms: Internal macros

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: Internal classes
async-p: Internal classes
async-p: Internal classes

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

D
duration-ms: Internal classes

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

F
fn: Internal classes

I
itens: Internal classes

L
limit-ms: Internal classes

N
name: Internal classes

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

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

R
result: Internal classes
runnable-error: Internal classes

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

T
timeout: Internal classes
timer: Internal classes

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:   C   H   L   N   P   R   S   T  
Index Entry  Section

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

H
hook-class: Internal classes

L
list-iterator: Internal classes

N
noloop.cacau: The noloop․cacau package

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

R
runnable: Internal classes
runner: Internal classes

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

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

Jump to:   C   H   L   N   P   R   S   T