The cardiogram Reference Manual

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

The cardiogram Reference Manual

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

Table of Contents


1 Introduction

Cardiogram 均

A framework for impromptu testing in Common Lisp.

WARNING: Work in progress.

Usage

The main objects in cardiogram are tests. To define a test use the deftest macro. It's syntax is:

(deftest <name> (<options>*) <docstring>* <form>*)

<options> := | :before <symbol> | <list-of-symbols>
             | :after <symbol> | <list-of-symbols>
             | :around <symbol> | <list-of-symbols>
             | :depends-on <dependency-c-d>
             | :time-limit <number>

<dependency-c-d> := ([or and] [<symbol> <dependency-c-d>]+)

To run a test, call it by name. For example:

(deftest myfunction-test ()
  (true (myfunction))


(myfunction-test)
;=> FAILED - TRUE.

This will run the code inside the test, then save the result. The second time you call (myfunction-test) the code won't be run, rather the test result will be printed. To run the test again, call it with the :run keyword like so:

(redefine-myfunction)

(myfunction-test :run)

;=> PASSED - TRUE

Chaining tests

You can combine tests using the :before, :around, and :after options. For example:

(deftest myotherfunction-test (:after myfunction-test)
  (false (myotherfunction (myfunction)))

(deftest myvariable-test (:around (myfunction-test myotherfunction-test))
  (of-type myvariable 'string))

(myfunction-test :run)

;=> Running test myvariable-test...
;   Running test myfunction-test...
;   Running test myvariable-test...
;   Running test myotherfunction-test...
;   Running test myvariable-test...

(myotherfunction-test :run)

;=> Running test myvariable-test...
;   Running test myotherfunction-test...
;   Running test myvariable-test...

(myvariable-test :run)

;=> Running test myvariable-test...

You can also tell a test to skip any test in it's combination by specifying it's name when you call it:

... FAILED - MYVARIABLE-TEST

(myfunction-test :run :skip `(myvariable-test))


;=> Running test myfunction-test...
;   Running test myotherfunction-test...

Test dependencies

To define dependencies for a test, use the :depends-on option.

(deftest myotherfunction-test (:after myfunction-test :depends-on (myvariable-test))
  ...)

(myfunction-test :run)

;=> Running test myvariable-test...
;   Skipping myfunction-test. Failed dependencies.

Additionally you can use the :dependency-of option to add the test being defined to another's dependencies.


(deftest myotherfunction-test (:dependency-of myfunction-test)
  ...)

(myfunction-test)

;=> Running test myotherfunction-test
; Test myotherfunction-test failed
; ... Dependency error... skipping test myfunction-test

Both :dependency-of and :depends-on accept dependency disjunctions and conjunctions of the form:

<dependency-expr>  := (<operator-keyword> <symbol>* <dependency-expr>*)
<operator-keyword> := :and :or

Tests are funcallable, so you can programatically call tests with Lisp's own funcall. For example:

(loop for sy being each symbol in *package* doing
      (when (tboundp sy)
        (funcall (symbol-test sy))))

Furthermore, tests will return t or nil whenever they pass or fail respectively.

; silly example

(when (myfunction-test)
  (asdf:make :mypackage))

Anonymous Tests

Sometimes you need to test something without being sure about how to test it. The test macro is a lambda form analog that returns an anonymous test[^1]. Tests defined anonymously can be used in combination with other named tests.

(test (:after myfunction-test)
  ...)

(funcall *)

;=> Running test TEST872...
;

(myfunction-test)

;=> Running test MYFUNCTION-TEST...
;   Running test TEST872...


(deftes myvar-test (:depends-on (test (:after myfunction-test) ...))
  ...)

Errors

A global variable called *ignore-errors* controls if a test invokes the debugger on error or not. It's set to nil by default. When set to t, errors will be ignored but sill reported. A test with an error is a failed test.


(setf *ignore-errors* t)

(deftest a ()
(+ 'a 1))

(a)

;=> Running test A...
;   Test A took 0.0s to run.
;   Test A FAIL
;
;   Value of 'A in (+ 'A 1) is A, not a NUMBER. 'A(+ 'A 1)NUMBER
;   NIL

Comparisons, valuations and formats.

Cardiogram provides the following valuations to be used inside a test's forms.

(true form)
; Tests if form is true

(false form)
; Tests if form is false

(fail form)
; Will always fail form

(pass form)
; Will always pass form

(is form expected)
; To test if form is eql to expected

(isnt form expected)
; To test if form isn't eql to expected

(is-values form expected)
; To test if the values of form are eql to the values of expected

(isnt-values form expected)
; Tests if  the falues of form aren't eql to de values of expected

(is-print form expected)
; Tests if form prints the same as expected

(eql-types form1 form2)
; Tests if form1 and form2 are of eql types

(of-type form expected)
; Tests if form is of type expected

(expands-1 form expected)
; Tests if form macroexpand-1s to expected

You can define new valuations by a two step process. First use the define-valuation macro. The body in define-valuation corresponds to the test used when calling a valuation. It should return true or false.

; (define-valuation valuation-name args &body body)

(define-valuation my-is (form expected)
  (my-eql form expected))

Next you need to define a reporter function for your valuation. To do this, use the define-format macro. The body in this macro should be either a string or the body of a function taking two arguments. The first argument is a list of the arguments passed to the valuation. The second is the result of the valuation. When defining a function. It should return a report string.

; (define-format valuation-name format-name args &body body)

(define-format my-is simple (args result)
  (with-output-to-string (s)
    (destructuring-bind (form expected) args
      (if result (princ form s) (princ "NOPE" s))))

The format simple is the default format in cardiogram and binary is the fall-back format. You can define new formats by individually adding your format to each valuation name. Then to use it do (setf *default-format* 'myformat).

(ql:quickload :alexandria)
(ql:quickload :cl-yaml)

(define-format fail myformat (args result)
  (declare (ignore args result))
  (yaml:emit-to-string
    (alexandria:alist-hash-table '(("result" . "failed")
                                   ("reason" . "Always Fails"))))

Cardiogram outputs report strings to a stream called *test-output* which defaults to *standard-output*. You can change it to whatever stream you like.

Fixes

Sometimes you need to run a test that changes an aspect of the environment. To fix the environment again, cardiogram has a few macros wrapping unwind-protect. The main one is with-fixes.


var1
;=> 4

var2
;=> 3

(with-fixes (var1 var2)
  ...
  (setf var1 3)
  (setf var2 4) ...)

var1
;=> 4

var2
;=> 3

Environments with automatic fixes

Also there are macros that automatically compute fixes for symbols whose symbol-name starts with f!. They are f!let, f!let*, f!block and f!labels

*global-var*

;=> 4

(f!let (...)
  (setf *global-var* 'symbol)
  (setf f!*global-var* "something else"))

*global-var*

;=> 4繙

Notice how preppending the variable name anywhere inside the f!let is sufficient.

You can define your own fixes with the defix macro.

; (defix name args &body body)
; where args must be a list of 1 element

(defix my-symbol-p (s)
  (when (my-symbol-p s)
    (setf s 5))

[^1]: Or rather a test bound to a symb


2 Systems

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


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

2.1 cardiogram

Simple test framework

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Long Description

# Cardiogram 均

A framework for impromptu testing in Common Lisp.

WARNING: Work in progress.

## Usage

The main objects in cardiogram are tests. To define a test use the
‘deftest‘ macro. It’s syntax is:

“‘
(deftest <name> (<options>*) <docstring>* <form>*)

<options> := | :before <symbol> | <list-of-symbols>
| :after <symbol> | <list-of-symbols>
| :around <symbol> | <list-of-symbols>
| :depends-on <dependency-c-d>
| :time-limit <number>

<dependency-c-d> := ([or and] [<symbol> <dependency-c-d>]+)
“‘

To run a test, call it by name. For example:

“‘common-lisp
(deftest myfunction-test ()
(true (myfunction))

(myfunction-test)
;=> FAILED - TRUE.

“‘

This will run the code inside the test, then save the result. The second time you call ‘(myfunction-test)‘ the code won’t be run, rather the test result will be printed. To run the test again, call it with
the ‘:run‘ keyword like so:

“‘common-lisp
(redefine-myfunction)

(myfunction-test :run)

;=> PASSED - TRUE

“‘

#### Chaining tests

You can combine tests using the ‘:before‘, ‘:around‘, and ‘:after‘ options. For example:

“‘common-lisp
(deftest myotherfunction-test (:after myfunction-test)
(false (myotherfunction (myfunction)))

(deftest myvariable-test (:around (myfunction-test myotherfunction-test))
(of-type myvariable ’string))

(myfunction-test :run)

;=> Running test myvariable-test...
; Running test myfunction-test...
; Running test myvariable-test...
; Running test myotherfunction-test...
; Running test myvariable-test...

(myotherfunction-test :run)

;=> Running test myvariable-test...
; Running test myotherfunction-test...
; Running test myvariable-test...

(myvariable-test :run)

;=> Running test myvariable-test...
“‘

You can also tell a test to skip any test in it’s combination by specifying it’s name
when you call it:

“‘common-lisp
... FAILED - MYVARIABLE-TEST

(myfunction-test :run :skip ‘(myvariable-test))

;=> Running test myfunction-test...
; Running test myotherfunction-test...
“‘

#### Test dependencies

To define dependencies for a test, use the ‘:depends-on‘ option.

“‘common-lisp
(deftest myotherfunction-test (:after myfunction-test :depends-on (myvariable-test))
...)

(myfunction-test :run)

;=> Running test myvariable-test...
; Skipping myfunction-test. Failed dependencies.

“‘

Additionally you can use the ‘:dependency-of‘ option to add the test being defined to
another’s dependencies.

“‘common-lisp

(deftest myotherfunction-test (:dependency-of myfunction-test)
...)

(myfunction-test)

;=> Running test myotherfunction-test
; Test myotherfunction-test failed
; ... Dependency error... skipping test myfunction-test
“‘

Both ‘:dependency-of‘ and ‘:depends-on‘ accept dependency disjunctions and conjunctions
of the form:

“‘common-lisp
<dependency-expr> := (<operator-keyword> <symbol>* <dependency-expr>*)
<operator-keyword> := :and :or
“‘

Tests are funcallable, so you can programatically call tests with Lisp’s own ‘funcall‘. For example:

“‘common-lisp
(loop for sy being each symbol in *package* doing
(when (tboundp sy)
(funcall (symbol-test sy))))
“‘

Furthermore, tests will return ‘t‘ or ‘nil‘ whenever they pass or fail respectively.

“‘common-lisp
; silly example

(when (myfunction-test)
(asdf:make :mypackage))

“‘

#### Anonymous Tests

Sometimes you need to test something without being sure about how to test it.
The ‘test‘ macro is a ‘lambda‘ form analog that returns an anonymous test[^1]. Tests defined anonymously can be used in combination with other named tests.

“‘common-lisp
(test (:after myfunction-test)
...)

(funcall *)

;=> Running test TEST872...
;

(myfunction-test)

;=> Running test MYFUNCTION-TEST...
; Running test TEST872...

(deftes myvar-test (:depends-on (test (:after myfunction-test) ...))
...)
“‘

#### Errors

A global variable called ‘*ignore-errors*‘ controls if a test invokes the debugger on error or not.
It’s set to ‘nil‘ by default. When set to ‘t‘, errors will be ignored but sill reported. A test
with an error is a failed test.

“‘common-lisp

(setf *ignore-errors* t)

(deftest a ()
(+ ’a 1))

(a)

;=> Running test A...
; Test A took 0.0s to run.
; Test A FAIL
;
; Value of ’A in (+ ’A 1) is A, not a NUMBER. ’A(+ ’A 1)NUMBER
; NIL
“‘

## Comparisons, valuations and formats.

Cardiogram provides the following valuations to be used inside a test’s forms.

“‘
(true form)
; Tests if form is true

(false form)
; Tests if form is false

(fail form)
; Will always fail form

(pass form)
; Will always pass form

(is form expected)
; To test if form is eql to expected

(isnt form expected)
; To test if form isn’t eql to expected

(is-values form expected)
; To test if the values of form are eql to the values of expected

(isnt-values form expected)
; Tests if the falues of form aren’t eql to de values of expected

(is-print form expected)
; Tests if form prints the same as expected

(eql-types form1 form2)
; Tests if form1 and form2 are of eql types

(of-type form expected)
; Tests if form is of type expected

(expands-1 form expected)
; Tests if form macroexpand-1s to expected
“‘

You can define new valuations by a two step process. First use the ‘define-valuation‘ macro. The body in ‘define-valuation‘ corresponds to the test used when calling a valuation. It should
return true or false.

“‘common-lisp
; (define-valuation valuation-name args &body body)

(define-valuation my-is (form expected)
(my-eql form expected))
“‘
Next you need to define a reporter function for your valuation. To do this, use the ‘define-format‘ macro. The body in this macro should be either a string or the body of a function taking two arguments.
The first argument is a list of the arguments passed to the valuation. The second is the result of
the valuation. When defining a function. It should return a report string.

“‘common-lisp
; (define-format valuation-name format-name args &body body)

(define-format my-is simple (args result)
(with-output-to-string (s)
(destructuring-bind (form expected) args
(if result (princ form s) (princ "NOPE" s))))
“‘

The format ‘simple‘ is the default format in cardiogram and ‘binary‘ is the fall-back format.
You can define new formats by individually
adding your format to each valuation name. Then to use it do ‘(setf *default-format* ’myformat)‘.

“‘common-lisp
(ql:quickload :alexandria)
(ql:quickload :cl-yaml)

(define-format fail myformat (args result)
(declare (ignore args result))
(yaml:emit-to-string
(alexandria:alist-hash-table ’(("result" . "failed")
("reason" . "Always Fails"))))

“‘

Cardiogram outputs report strings to a stream called ‘*test-output*‘ which defaults to ‘*standard-output*‘. You can change it to whatever stream you like.

## Fixes

Sometimes you need to run a test that changes an aspect of the environment. To fix the environment again, cardiogram has a few macros wrapping ‘unwind-protect‘. The main one is ‘with-fixes‘.

“‘common-lisp

var1
;=> 4

var2
;=> 3

(with-fixes (var1 var2)
...
(setf var1 3)
(setf var2 4) ...)

var1
;=> 4

var2
;=> 3

“‘

#### Environments with automatic fixes

Also there are macros that automatically compute fixes for symbols whose ‘symbol-name‘
starts with ‘f!‘. They are ‘f!let‘, ‘f!let*‘, ‘f!block‘ and ‘f!labels‘

“‘common-lisp
*global-var*

;=> 4

(f!let (...)
(setf *global-var* ’symbol)
(setf f!*global-var* "something else"))

*global-var*

;=> 4繙

“‘

Notice how preppending the variable name anywhere inside the ‘f!let‘ is sufficient.

You can define your own fixes with the ‘defix‘ macro.

“‘common-lisp
; (defix name args &body body)
; where args must be a list of 1 element

(defix my-symbol-p (s)
(when (my-symbol-p s)
(setf s 5))

“‘

[^1]: Or rather a test bound to a symbol.

Version

0.1.0

Dependency

cardiogram/all (system).

Source

cardiogram.asd.


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

2.2 cardiogram/all

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


2.3 cardiogram/fixtures

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


2.4 cardiogram/toolkit

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Source

cardiogram.asd.


2.5 cardiogram/conditions

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Source

cardiogram.asd.


2.6 cardiogram/tests

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


2.7 cardiogram/valuations

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


2.8 cardiogram/introspection

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


2.9 cardiogram/annotations

Maintainer

Abraham Aguilar

Author

Abraham Aguilar

Home Page

https://gitlab.com/a.aguilar/cardiogram

License

MIT

Dependencies
Source

cardiogram.asd.


3 Files

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


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

3.1 Lisp


3.1.2 cardiogram/all/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/all (system).

Packages

cardiogram/all.


3.1.3 cardiogram/fixtures/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/fixtures (system).

Packages

cardiogram/fixtures.

Public Interface
Internals

3.1.4 cardiogram/toolkit/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/toolkit (system).

Packages

cardiogram/toolkit.

Public Interface

3.1.5 cardiogram/conditions/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/conditions (system).

Packages

cardiogram/conditions.

Public Interface
Internals

3.1.6 cardiogram/tests/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/tests (system).

Packages

cardiogram/tests.

Public Interface
Internals

3.1.7 cardiogram/valuations/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/valuations (system).

Packages

cardiogram/valuations.

Public Interface
Internals

3.1.8 cardiogram/introspection/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/introspection (system).

Packages

cardiogram/introspection.

Public Interface

show-deftest (function).


3.1.9 cardiogram/annotations/file-type.lisp

Source

cardiogram.asd.

Parent Component

cardiogram/annotations (system).

Packages

cardiogram/annotations.

Public Interface

in (macro).


4 Packages

Packages are listed by definition order.


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

4.1 cardiogram/toolkit

Source

file-type.lisp.

Use List

common-lisp.

Used By List
Public Interface

4.2 cardiogram/fixtures

Source

file-type.lisp.

Nickname

cardiofix

Use List
Used By List

cardiogram/all.

Public Interface
Internals

4.3 cardiogram/valuations

Source

file-type.lisp.

Use List
Used By List

cardiogram/all.

Public Interface
Internals

4.4 cardiogram/annotations

Source

file-type.lisp.

Use List
Used By List

cardiogram/all.

Public Interface

in (macro).


4.5 cardiogram/tests

Source

file-type.lisp.

Use List
Used By List
Public Interface
Internals

4.7 cardiogram/introspection

Source

file-type.lisp.

Use List
Used By List

cardiogram/all.

Public Interface

show-deftest (function).


4.8 cardiogram/conditions

Source

file-type.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

5 Definitions

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


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

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *default-format*
Package

cardiogram/tests.

Source

file-type.lisp.

Special Variable: *ignore-errors*
Package

cardiogram/conditions.

Source

file-type.lisp.

Special Variable: *ignore-test-errors*
Package

cardiogram/conditions.

Source

file-type.lisp.

Special Variable: *test-output*
Package

cardiogram/tests.

Source

file-type.lisp.


5.1.2 Macros

Macro: define-valuation (name (&rest args) &body body)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: defix (name (s &optional &key auto) &body body)
Package

cardiogram/fixtures.

Source

file-type.lisp.

Macro: deftest (name (&rest options) &body body)
Package

cardiogram/tests.

Source

file-type.lisp.

Macro: f!block (name &body body)

Block that fixes the

Package

cardiogram/fixtures.

Source

file-type.lisp.

Macro: f!labels (bindings &body body)

Block that fixes the

Package

cardiogram/fixtures.

Source

file-type.lisp.

Macro: f!let (bindings &body body)

Block that fixes the

Package

cardiogram/fixtures.

Source

file-type.lisp.

Macro: f!let* (bindings &body body)

Block that fixes the

Package

cardiogram/fixtures.

Source

file-type.lisp.

Macro: in (x def)
Package

cardiogram/annotations.

Source

file-type.lisp.

Macro: is-values (form expected)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: isnt-values (form expected)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: prints (form expected)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: test ((&rest options) &body body)
Package

cardiogram/tests.

Source

file-type.lisp.

Macro: with-fixes (symbols &body body)

Run the forms in BODY and fix the SYMBOLS

Package

cardiogram/fixtures.

Source

file-type.lisp.


5.1.3 Ordinary functions

Function: check-dependencies (dependency-expr)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: ensure-test (name initargs &key combination dependency-of)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: eql-types (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: expands-1 (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: fail (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: flatten (list)
Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: is (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: is-false (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: is-true (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: isnt (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: k! (&rest args)
Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: l! (&rest args)
Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: of-type (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: parse-body (body-expr &optional &key strict)

Returns (values body declarations docstring)
both body and declarations are returned as lists, docstring as a string

Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: pass (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: s! (&rest args)

Build string PRINCing args. If at any point in the args
a string with the char ~ is found, this string is treated as a FORMAT control string taking as many arguments from args as ~’s are found in the control string

Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: show-deftest (test)
Package

cardiogram/introspection.

Source

file-type.lisp.

Function: sy! (&rest args)
Package

cardiogram/toolkit.

Source

file-type.lisp.

Function: symbol-fix (symbol)
Package

cardiogram/fixtures.

Source

file-type.lisp.

Function: (setf symbol-fix) (symbol)
Package

cardiogram/fixtures.

Source

file-type.lisp.

Function: symbol-test (symbol)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: (setf symbol-test) (symbol)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: symbol-valuation (valuation)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: (setf symbol-valuation) (valuation)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: tboundp (symbol)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: test-passes-p (test)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: vboundp (symbol)
Package

cardiogram/valuations.

Source

file-type.lisp.


5.1.4 Generic functions

Generic Reader: combination-test-name (condition)
Generic Writer: (setf combination-test-name) (condition)
Package

cardiogram/conditions.

Methods
Reader Method: combination-test-name ((condition undefined-test-in-combination))
Writer Method: (setf combination-test-name) ((condition undefined-test-in-combination))
Source

file-type.lisp.

Target Slot

combination-test.

Generic Reader: dependency-name (condition)
Generic Writer: (setf dependency-name) (condition)
Package

cardiogram/conditions.

Methods
Reader Method: dependency-name ((condition undefined-test-in-dependency-of))
Writer Method: (setf dependency-name) ((condition undefined-test-in-dependency-of))
Source

file-type.lisp.

Target Slot

dependency-name.

Generic Reader: fix-autop (object)
Package

cardiogram/fixtures.

Methods
Reader Method: fix-autop ((fix fix))

automatically generated reader method

Source

file-type.lisp.

Target Slot

auto.

Generic Writer: (setf fix-autop) (object)
Package

cardiogram/fixtures.

Methods
Writer Method: (setf fix-autop) ((fix fix))

automatically generated writer method

Source

file-type.lisp.

Target Slot

auto.

Generic Reader: test-after (object)
Package

cardiogram/tests.

Methods
Reader Method: test-after ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

after.

Generic Writer: (setf test-after) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-after) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

after.

Generic Reader: test-around (object)
Package

cardiogram/tests.

Methods
Reader Method: test-around ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

around.

Generic Writer: (setf test-around) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-around) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

around.

Generic Reader: test-before (object)
Package

cardiogram/tests.

Methods
Reader Method: test-before ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

before.

Generic Writer: (setf test-before) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-before) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

before.

Generic Reader: test-body (object)
Package

cardiogram/tests.

Methods
Reader Method: test-body ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

body.

Generic Writer: (setf test-body) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-body) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

body.

Generic Reader: test-dependencies (object)
Package

cardiogram/tests.

Methods
Reader Method: test-dependencies ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

dependencies.

Generic Writer: (setf test-dependencies) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-dependencies) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

dependencies.

Generic Reader: test-forms (object)
Package

cardiogram/tests.

Methods
Reader Method: test-forms ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

forms.

Generic Writer: (setf test-forms) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-forms) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

forms.

Generic Reader: test-name (object)
Package

cardiogram/tests.

Methods
Reader Method: test-name ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

name.

Generic Writer: (setf test-name) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-name) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

name.

Generic Reader: test-options (object)
Package

cardiogram/tests.

Methods
Reader Method: test-options ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

options.

Generic Writer: (setf test-options) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-options) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

options.

Generic Reader: test-results (object)
Package

cardiogram/tests.

Methods
Reader Method: test-results ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

results.

Generic Writer: (setf test-results) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-results) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

results.

Generic Reader: test-status (object)
Package

cardiogram/tests.

Methods
Reader Method: test-status ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

status.

Generic Writer: (setf test-status) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-status) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

status.

Generic Reader: test-time-limit (object)
Package

cardiogram/tests.

Methods
Reader Method: test-time-limit ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

time-limit.

Generic Writer: (setf test-time-limit) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-time-limit) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

time-limit.

Generic Reader: undefined-test-name (condition)
Generic Writer: (setf undefined-test-name) (condition)
Package

cardiogram/conditions.

Methods
Reader Method: undefined-test-name ((condition undefined-test))
Writer Method: (setf undefined-test-name) ((condition undefined-test))
Source

file-type.lisp.

Target Slot

name.

Generic Reader: valuation-applicable-formats (object)
Package

cardiogram/valuations.

Methods
Reader Method: valuation-applicable-formats ((valuation valuation))

automatically generated reader method

Source

file-type.lisp.

Target Slot

applicable-formats.

Generic Writer: (setf valuation-applicable-formats) (object)
Package

cardiogram/valuations.

Methods
Writer Method: (setf valuation-applicable-formats) ((valuation valuation))

automatically generated writer method

Source

file-type.lisp.

Target Slot

applicable-formats.

Generic Reader: valuation-name (object)
Package

cardiogram/valuations.

Methods
Reader Method: valuation-name ((valuation valuation))

automatically generated reader method

Source

file-type.lisp.

Target Slot

name.

Generic Writer: (setf valuation-name) (object)
Package

cardiogram/valuations.

Methods
Writer Method: (setf valuation-name) ((valuation valuation))

automatically generated writer method

Source

file-type.lisp.

Target Slot

name.

Generic Reader: valuation-test (object)
Package

cardiogram/valuations.

Methods
Reader Method: valuation-test ((valuation valuation))

automatically generated reader method

Source

file-type.lisp.

Target Slot

test.

Generic Writer: (setf valuation-test) (object)
Package

cardiogram/valuations.

Methods
Writer Method: (setf valuation-test) ((valuation valuation))

automatically generated writer method

Source

file-type.lisp.

Target Slot

test.


5.1.5 Standalone methods

Method: initialize-instance :after ((val valuation) &key)
Source

file-type.lisp.

Method: initialize-instance :after ((format format-class) &key)
Source

file-type.lisp.

Method: initialize-instance :after ((test test) &key)
Source

file-type.lisp.


5.1.6 Conditions

Condition: test-dependencies-error

To be signaled when checking dependencies

Package

cardiogram/conditions.

Source

file-type.lisp.

Direct superclasses

test-failure.

Condition: test-failure
Package

cardiogram/conditions.

Source

file-type.lisp.

Direct superclasses

error.

Direct subclasses

test-dependencies-error.

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

test-failure-test-name.

Writers

(setf test-failure-test-name).

Slot: results
Initargs

:results

Readers

test-failure-test-results.

Writers

(setf test-failure-test-results).

Condition: undefined-test
Package

cardiogram/conditions.

Source

file-type.lisp.

Direct superclasses

error.

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

undefined-test-name.

Writers

(setf undefined-test-name).

Condition: undefined-test-in-combination
Package

cardiogram/conditions.

Source

file-type.lisp.

Direct superclasses

undefined-test.

Direct methods
Direct slots
Slot: combination-test
Initargs

:combination-test

Readers

combination-test-name.

Writers

(setf combination-test-name).

Condition: undefined-test-in-dependency-of
Package

cardiogram/conditions.

Source

file-type.lisp.

Direct superclasses

undefined-test.

Direct methods
Direct slots
Slot: dependency-name
Initargs

:dependency-name

Readers

dependency-name.

Writers

(setf dependency-name).


Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Classes

Class: test
Package

cardiogram/tests.

Source

file-type.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: forms
Initargs

:forms

Readers

test-forms.

Writers

(setf test-forms).

Slot: body
Initargs

:body

Readers

test-body.

Writers

(setf test-body).

Slot: options
Initargs

:options

Readers

test-options.

Writers

(setf test-options).

Slot: name
Initargs

:name

Readers

test-name.

Writers

(setf test-name).

Slot: before
Initargs

:before

Readers

test-before.

Writers

(setf test-before).

Slot: after
Initargs

:after

Readers

test-after.

Writers

(setf test-after).

Slot: around
Initargs

:around

Readers

test-around.

Writers

(setf test-around).

Slot: dependencies
Initargs

:dependencies

Readers

test-dependencies.

Writers

(setf test-dependencies).

Slot: results
Initargs

:results

Readers

test-results.

Writers

(setf test-results).

Slot: time-limit
Initargs

:time-limit

Readers

test-time-limit.

Writers

(setf test-time-limit).

Slot: status
Readers

test-status.

Writers

(setf test-status).

Slot: documentation
Package

common-lisp.

Initargs

:documentation

Readers

test-documentation.

Writers

(setf test-documentation).


5.2 Internals


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

5.2.1 Special variables

Special Variable: *fixes*
Package

cardiogram/fixtures.

Source

file-type.lisp.


5.2.2 Macros

Macro: define-format (valuation name args &body body)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: delay (&body form)
Package

cardiogram/valuations.

Source

file-type.lisp.

Macro: time-limit (form time-limit)
Package

cardiogram/valuations.

Source

file-type.lisp.


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

5.2.3 Ordinary functions

Function: add-format-to-valuation (valuation format)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: compute-test-verdict-using-results (test)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: ensure-dependency-expr (expr)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: ensure-test-status (test)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: find-format-for-valuation (valuation)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: force (thunk)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: is-values% (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: isnt-values% (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: make-fixes (symbol-list)
Package

cardiogram/fixtures.

Source

file-type.lisp.

Function: prints% (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.

Function: resolve-dependency-of (test expr)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: resolve-test-combination (test combination)
Package

cardiogram/tests.

Source

file-type.lisp.

Function: specified-fixes (spec)
Package

cardiogram/fixtures.

Source

file-type.lisp.

Function: time-limit% (&rest args)
Package

cardiogram/valuations.

Source

file-type.lisp.


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

5.2.4 Generic functions

Generic Reader: format-formatter (object)
Package

cardiogram/valuations.

Methods
Reader Method: format-formatter ((format-class format-class))

automatically generated reader method

Source

file-type.lisp.

Target Slot

formatter.

Generic Writer: (setf format-formatter) (object)
Package

cardiogram/valuations.

Methods
Writer Method: (setf format-formatter) ((format-class format-class))

automatically generated writer method

Source

file-type.lisp.

Target Slot

formatter.

Generic Reader: format-name (object)
Package

cardiogram/valuations.

Methods
Reader Method: format-name ((format-class format-class))

automatically generated reader method

Source

file-type.lisp.

Target Slot

name.

Generic Writer: (setf format-name) (object)
Package

cardiogram/valuations.

Methods
Writer Method: (setf format-name) ((format-class format-class))

automatically generated writer method

Source

file-type.lisp.

Target Slot

name.

Generic Function: report-test (test format)
Package

cardiogram/tests.

Source

file-type.lisp.

Methods
Method: report-test (test format)
Generic Reader: test-documentation (object)
Package

cardiogram/tests.

Methods
Reader Method: test-documentation ((test test))

automatically generated reader method

Source

file-type.lisp.

Target Slot

documentation.

Generic Writer: (setf test-documentation) (object)
Package

cardiogram/tests.

Methods
Writer Method: (setf test-documentation) ((test test))

automatically generated writer method

Source

file-type.lisp.

Target Slot

documentation.

Generic Reader: test-failure-test-name (condition)
Generic Writer: (setf test-failure-test-name) (condition)
Package

cardiogram/conditions.

Methods
Reader Method: test-failure-test-name ((condition test-failure))
Writer Method: (setf test-failure-test-name) ((condition test-failure))
Source

file-type.lisp.

Target Slot

name.

Generic Reader: test-failure-test-results (condition)
Generic Writer: (setf test-failure-test-results) (condition)
Package

cardiogram/conditions.

Methods
Reader Method: test-failure-test-results ((condition test-failure))
Writer Method: (setf test-failure-test-results) ((condition test-failure))
Source

file-type.lisp.

Target Slot

results.


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

5.2.5 Classes

Class: fix
Package

cardiogram/fixtures.

Source

file-type.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: auto
Initargs

:auto

Readers

fix-autop.

Writers

(setf fix-autop).

Class: format-class
Package

cardiogram/valuations.

Source

file-type.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: formatter
Package

common-lisp.

Type

(or string function)

Initargs

:formatter

Readers

format-formatter.

Writers

(setf format-formatter).

Slot: name
Initargs

:name

Readers

format-name.

Writers

(setf format-name).

Class: valuation
Package

cardiogram/valuations.

Source

file-type.lisp.

Direct superclasses

funcallable-standard-object.

Direct methods
Direct slots
Slot: applicable-formats
Readers

valuation-applicable-formats.

Writers

(setf valuation-applicable-formats).

Slot: name
Initargs

:name

Readers

valuation-name.

Writers

(setf valuation-name).

Slot: test
Package

cardiogram/tests.

Initargs

:test

Readers

valuation-test.

Writers

(setf valuation-test).


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   I   K   L   M   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf combination-test-name): Public generic functions
(setf combination-test-name): Public generic functions
(setf dependency-name): Public generic functions
(setf dependency-name): Public generic functions
(setf fix-autop): Public generic functions
(setf fix-autop): Public generic functions
(setf format-formatter): Private generic functions
(setf format-formatter): Private generic functions
(setf format-name): Private generic functions
(setf format-name): Private generic functions
(setf symbol-fix): Public ordinary functions
(setf symbol-test): Public ordinary functions
(setf symbol-valuation): Public ordinary functions
(setf test-after): Public generic functions
(setf test-after): Public generic functions
(setf test-around): Public generic functions
(setf test-around): Public generic functions
(setf test-before): Public generic functions
(setf test-before): Public generic functions
(setf test-body): Public generic functions
(setf test-body): Public generic functions
(setf test-dependencies): Public generic functions
(setf test-dependencies): Public generic functions
(setf test-documentation): Private generic functions
(setf test-documentation): Private generic functions
(setf test-failure-test-name): Private generic functions
(setf test-failure-test-name): Private generic functions
(setf test-failure-test-results): Private generic functions
(setf test-failure-test-results): Private generic functions
(setf test-forms): Public generic functions
(setf test-forms): Public generic functions
(setf test-name): Public generic functions
(setf test-name): Public generic functions
(setf test-options): Public generic functions
(setf test-options): Public generic functions
(setf test-results): Public generic functions
(setf test-results): Public generic functions
(setf test-status): Public generic functions
(setf test-status): Public generic functions
(setf test-time-limit): Public generic functions
(setf test-time-limit): Public generic functions
(setf undefined-test-name): Public generic functions
(setf undefined-test-name): Public generic functions
(setf valuation-applicable-formats): Public generic functions
(setf valuation-applicable-formats): Public generic functions
(setf valuation-name): Public generic functions
(setf valuation-name): Public generic functions
(setf valuation-test): Public generic functions
(setf valuation-test): Public generic functions

A
add-format-to-valuation: Private ordinary functions

C
check-dependencies: Public ordinary functions
combination-test-name: Public generic functions
combination-test-name: Public generic functions
compute-test-verdict-using-results: Private ordinary functions

D
define-format: Private macros
define-valuation: Public macros
defix: Public macros
deftest: Public macros
delay: Private macros
dependency-name: Public generic functions
dependency-name: Public generic functions

E
ensure-dependency-expr: Private ordinary functions
ensure-test: Public ordinary functions
ensure-test-status: Private ordinary functions
eql-types: Public ordinary functions
expands-1: Public ordinary functions

F
f!block: Public macros
f!labels: Public macros
f!let: Public macros
f!let*: Public macros
fail: Public ordinary functions
find-format-for-valuation: Private ordinary functions
fix-autop: Public generic functions
fix-autop: Public generic functions
flatten: Public ordinary functions
force: Private ordinary functions
format-formatter: Private generic functions
format-formatter: Private generic functions
format-name: Private generic functions
format-name: Private generic functions
Function, (setf symbol-fix): Public ordinary functions
Function, (setf symbol-test): Public ordinary functions
Function, (setf symbol-valuation): Public ordinary functions
Function, add-format-to-valuation: Private ordinary functions
Function, check-dependencies: Public ordinary functions
Function, compute-test-verdict-using-results: Private ordinary functions
Function, ensure-dependency-expr: Private ordinary functions
Function, ensure-test: Public ordinary functions
Function, ensure-test-status: Private ordinary functions
Function, eql-types: Public ordinary functions
Function, expands-1: Public ordinary functions
Function, fail: Public ordinary functions
Function, find-format-for-valuation: Private ordinary functions
Function, flatten: Public ordinary functions
Function, force: Private ordinary functions
Function, is: Public ordinary functions
Function, is-false: Public ordinary functions
Function, is-true: Public ordinary functions
Function, is-values%: Private ordinary functions
Function, isnt: Public ordinary functions
Function, isnt-values%: Private ordinary functions
Function, k!: Public ordinary functions
Function, l!: Public ordinary functions
Function, make-fixes: Private ordinary functions
Function, of-type: Public ordinary functions
Function, parse-body: Public ordinary functions
Function, pass: Public ordinary functions
Function, prints%: Private ordinary functions
Function, resolve-dependency-of: Private ordinary functions
Function, resolve-test-combination: Private ordinary functions
Function, s!: Public ordinary functions
Function, show-deftest: Public ordinary functions
Function, specified-fixes: Private ordinary functions
Function, sy!: Public ordinary functions
Function, symbol-fix: Public ordinary functions
Function, symbol-test: Public ordinary functions
Function, symbol-valuation: Public ordinary functions
Function, tboundp: Public ordinary functions
Function, test-passes-p: Public ordinary functions
Function, time-limit%: Private ordinary functions
Function, vboundp: Public ordinary functions

G
Generic Function, (setf combination-test-name): Public generic functions
Generic Function, (setf dependency-name): Public generic functions
Generic Function, (setf fix-autop): Public generic functions
Generic Function, (setf format-formatter): Private generic functions
Generic Function, (setf format-name): Private generic functions
Generic Function, (setf test-after): Public generic functions
Generic Function, (setf test-around): Public generic functions
Generic Function, (setf test-before): Public generic functions
Generic Function, (setf test-body): Public generic functions
Generic Function, (setf test-dependencies): Public generic functions
Generic Function, (setf test-documentation): Private generic functions
Generic Function, (setf test-failure-test-name): Private generic functions
Generic Function, (setf test-failure-test-results): Private generic functions
Generic Function, (setf test-forms): Public generic functions
Generic Function, (setf test-name): Public generic functions
Generic Function, (setf test-options): Public generic functions
Generic Function, (setf test-results): Public generic functions
Generic Function, (setf test-status): Public generic functions
Generic Function, (setf test-time-limit): Public generic functions
Generic Function, (setf undefined-test-name): Public generic functions
Generic Function, (setf valuation-applicable-formats): Public generic functions
Generic Function, (setf valuation-name): Public generic functions
Generic Function, (setf valuation-test): Public generic functions
Generic Function, combination-test-name: Public generic functions
Generic Function, dependency-name: Public generic functions
Generic Function, fix-autop: Public generic functions
Generic Function, format-formatter: Private generic functions
Generic Function, format-name: Private generic functions
Generic Function, report-test: Private generic functions
Generic Function, test-after: Public generic functions
Generic Function, test-around: Public generic functions
Generic Function, test-before: Public generic functions
Generic Function, test-body: Public generic functions
Generic Function, test-dependencies: Public generic functions
Generic Function, test-documentation: Private generic functions
Generic Function, test-failure-test-name: Private generic functions
Generic Function, test-failure-test-results: Private generic functions
Generic Function, test-forms: Public generic functions
Generic Function, test-name: Public generic functions
Generic Function, test-options: Public generic functions
Generic Function, test-results: Public generic functions
Generic Function, test-status: Public generic functions
Generic Function, test-time-limit: Public generic functions
Generic Function, undefined-test-name: Public generic functions
Generic Function, valuation-applicable-formats: Public generic functions
Generic Function, valuation-name: Public generic functions
Generic Function, valuation-test: Public generic functions

I
in: Public macros
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
is: Public ordinary functions
is-false: Public ordinary functions
is-true: Public ordinary functions
is-values: Public macros
is-values%: Private ordinary functions
isnt: Public ordinary functions
isnt-values: Public macros
isnt-values%: Private ordinary functions

K
k!: Public ordinary functions

L
l!: Public ordinary functions

M
Macro, define-format: Private macros
Macro, define-valuation: Public macros
Macro, defix: Public macros
Macro, deftest: Public macros
Macro, delay: Private macros
Macro, f!block: Public macros
Macro, f!labels: Public macros
Macro, f!let: Public macros
Macro, f!let*: Public macros
Macro, in: Public macros
Macro, is-values: Public macros
Macro, isnt-values: Public macros
Macro, prints: Public macros
Macro, test: Public macros
Macro, time-limit: Private macros
Macro, with-fixes: Public macros
make-fixes: Private ordinary functions
Method, (setf combination-test-name): Public generic functions
Method, (setf dependency-name): Public generic functions
Method, (setf fix-autop): Public generic functions
Method, (setf format-formatter): Private generic functions
Method, (setf format-name): Private generic functions
Method, (setf test-after): Public generic functions
Method, (setf test-around): Public generic functions
Method, (setf test-before): Public generic functions
Method, (setf test-body): Public generic functions
Method, (setf test-dependencies): Public generic functions
Method, (setf test-documentation): Private generic functions
Method, (setf test-failure-test-name): Private generic functions
Method, (setf test-failure-test-results): Private generic functions
Method, (setf test-forms): Public generic functions
Method, (setf test-name): Public generic functions
Method, (setf test-options): Public generic functions
Method, (setf test-results): Public generic functions
Method, (setf test-status): Public generic functions
Method, (setf test-time-limit): Public generic functions
Method, (setf undefined-test-name): Public generic functions
Method, (setf valuation-applicable-formats): Public generic functions
Method, (setf valuation-name): Public generic functions
Method, (setf valuation-test): Public generic functions
Method, combination-test-name: Public generic functions
Method, dependency-name: Public generic functions
Method, fix-autop: Public generic functions
Method, format-formatter: Private generic functions
Method, format-name: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, report-test: Private generic functions
Method, test-after: Public generic functions
Method, test-around: Public generic functions
Method, test-before: Public generic functions
Method, test-body: Public generic functions
Method, test-dependencies: Public generic functions
Method, test-documentation: Private generic functions
Method, test-failure-test-name: Private generic functions
Method, test-failure-test-results: Private generic functions
Method, test-forms: Public generic functions
Method, test-name: Public generic functions
Method, test-options: Public generic functions
Method, test-results: Public generic functions
Method, test-status: Public generic functions
Method, test-time-limit: Public generic functions
Method, undefined-test-name: Public generic functions
Method, valuation-applicable-formats: Public generic functions
Method, valuation-name: Public generic functions
Method, valuation-test: Public generic functions

O
of-type: Public ordinary functions

P
parse-body: Public ordinary functions
pass: Public ordinary functions
prints: Public macros
prints%: Private ordinary functions

R
report-test: Private generic functions
report-test: Private generic functions
resolve-dependency-of: Private ordinary functions
resolve-test-combination: Private ordinary functions

S
s!: Public ordinary functions
show-deftest: Public ordinary functions
specified-fixes: Private ordinary functions
sy!: Public ordinary functions
symbol-fix: Public ordinary functions
symbol-test: Public ordinary functions
symbol-valuation: Public ordinary functions

T
tboundp: Public ordinary functions
test: Public macros
test-after: Public generic functions
test-after: Public generic functions
test-around: Public generic functions
test-around: Public generic functions
test-before: Public generic functions
test-before: Public generic functions
test-body: Public generic functions
test-body: Public generic functions
test-dependencies: Public generic functions
test-dependencies: Public generic functions
test-documentation: Private generic functions
test-documentation: Private generic functions
test-failure-test-name: Private generic functions
test-failure-test-name: Private generic functions
test-failure-test-results: Private generic functions
test-failure-test-results: Private generic functions
test-forms: Public generic functions
test-forms: Public generic functions
test-name: Public generic functions
test-name: Public generic functions
test-options: Public generic functions
test-options: Public generic functions
test-passes-p: Public ordinary functions
test-results: Public generic functions
test-results: Public generic functions
test-status: Public generic functions
test-status: Public generic functions
test-time-limit: Public generic functions
test-time-limit: Public generic functions
time-limit: Private macros
time-limit%: Private ordinary functions

U
undefined-test-name: Public generic functions
undefined-test-name: Public generic functions

V
valuation-applicable-formats: Public generic functions
valuation-applicable-formats: Public generic functions
valuation-name: Public generic functions
valuation-name: Public generic functions
valuation-test: Public generic functions
valuation-test: Public generic functions
vboundp: Public ordinary functions

W
with-fixes: Public macros

Jump to:   (  
A   C   D   E   F   G   I   K   L   M   O   P   R   S   T   U   V   W  

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

A.3 Variables

Jump to:   *  
A   B   C   D   F   N   O   R   S   T  
Index Entry  Section

*
*default-format*: Public special variables
*fixes*: Private special variables
*ignore-errors*: Public special variables
*ignore-test-errors*: Public special variables
*test-output*: Public special variables

A
after: Public classes
applicable-formats: Private classes
around: Public classes
auto: Private classes

B
before: Public classes
body: Public classes

C
combination-test: Public conditions

D
dependencies: Public classes
dependency-name: Public conditions
documentation: Public classes

F
formatter: Private classes
forms: Public classes

N
name: Public conditions
name: Public conditions
name: Public classes
name: Private classes
name: Private classes

O
options: Public classes

R
results: Public conditions
results: Public classes

S
Slot, after: Public classes
Slot, applicable-formats: Private classes
Slot, around: Public classes
Slot, auto: Private classes
Slot, before: Public classes
Slot, body: Public classes
Slot, combination-test: Public conditions
Slot, dependencies: Public classes
Slot, dependency-name: Public conditions
Slot, documentation: Public classes
Slot, formatter: Private classes
Slot, forms: Public classes
Slot, name: Public conditions
Slot, name: Public conditions
Slot, name: Public classes
Slot, name: Private classes
Slot, name: Private classes
Slot, options: Public classes
Slot, results: Public conditions
Slot, results: Public classes
Slot, status: Public classes
Slot, test: Private classes
Slot, time-limit: Public classes
Special Variable, *default-format*: Public special variables
Special Variable, *fixes*: Private special variables
Special Variable, *ignore-errors*: Public special variables
Special Variable, *ignore-test-errors*: Public special variables
Special Variable, *test-output*: Public special variables
status: Public classes

T
test: Private classes
time-limit: Public classes

Jump to:   *  
A   B   C   D   F   N   O   R   S   T  

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

A.4 Data types

Jump to:   C   F   P   S   T   U   V  
Index Entry  Section

C
cardiogram: The cardiogram system
cardiogram.asd: The cardiogram/cardiogram兀sd file
cardiogram/all: The cardiogram/all system
cardiogram/all: The cardiogram/all package
cardiogram/annotations: The cardiogram/annotations system
cardiogram/annotations: The cardiogram/annotations package
cardiogram/conditions: The cardiogram/conditions system
cardiogram/conditions: The cardiogram/conditions package
cardiogram/fixtures: The cardiogram/fixtures system
cardiogram/fixtures: The cardiogram/fixtures package
cardiogram/introspection: The cardiogram/introspection system
cardiogram/introspection: The cardiogram/introspection package
cardiogram/tests: The cardiogram/tests system
cardiogram/tests: The cardiogram/tests package
cardiogram/toolkit: The cardiogram/toolkit system
cardiogram/toolkit: The cardiogram/toolkit package
cardiogram/valuations: The cardiogram/valuations system
cardiogram/valuations: The cardiogram/valuations package
Class, fix: Private classes
Class, format-class: Private classes
Class, test: Public classes
Class, valuation: Private classes
Condition, test-dependencies-error: Public conditions
Condition, test-failure: Public conditions
Condition, undefined-test: Public conditions
Condition, undefined-test-in-combination: Public conditions
Condition, undefined-test-in-dependency-of: Public conditions

F
File, cardiogram.asd: The cardiogram/cardiogram兀sd file
File, file-type.lisp: The cardiogram/all/file-type子isp file
File, file-type.lisp: The cardiogram/fixtures/file-type子isp file
File, file-type.lisp: The cardiogram/toolkit/file-type子isp file
File, file-type.lisp: The cardiogram/conditions/file-type子isp file
File, file-type.lisp: The cardiogram/tests/file-type子isp file
File, file-type.lisp: The cardiogram/valuations/file-type子isp file
File, file-type.lisp: The cardiogram/introspection/file-type子isp file
File, file-type.lisp: The cardiogram/annotations/file-type子isp file
file-type.lisp: The cardiogram/all/file-type子isp file
file-type.lisp: The cardiogram/fixtures/file-type子isp file
file-type.lisp: The cardiogram/toolkit/file-type子isp file
file-type.lisp: The cardiogram/conditions/file-type子isp file
file-type.lisp: The cardiogram/tests/file-type子isp file
file-type.lisp: The cardiogram/valuations/file-type子isp file
file-type.lisp: The cardiogram/introspection/file-type子isp file
file-type.lisp: The cardiogram/annotations/file-type子isp file
fix: Private classes
format-class: Private classes

P
Package, cardiogram/all: The cardiogram/all package
Package, cardiogram/annotations: The cardiogram/annotations package
Package, cardiogram/conditions: The cardiogram/conditions package
Package, cardiogram/fixtures: The cardiogram/fixtures package
Package, cardiogram/introspection: The cardiogram/introspection package
Package, cardiogram/tests: The cardiogram/tests package
Package, cardiogram/toolkit: The cardiogram/toolkit package
Package, cardiogram/valuations: The cardiogram/valuations package

S
System, cardiogram: The cardiogram system
System, cardiogram/all: The cardiogram/all system
System, cardiogram/annotations: The cardiogram/annotations system
System, cardiogram/conditions: The cardiogram/conditions system
System, cardiogram/fixtures: The cardiogram/fixtures system
System, cardiogram/introspection: The cardiogram/introspection system
System, cardiogram/tests: The cardiogram/tests system
System, cardiogram/toolkit: The cardiogram/toolkit system
System, cardiogram/valuations: The cardiogram/valuations system

T
test: Public classes
test-dependencies-error: Public conditions
test-failure: Public conditions

U
undefined-test: Public conditions
undefined-test-in-combination: Public conditions
undefined-test-in-dependency-of: Public conditions

V
valuation: Private classes

Jump to:   C   F   P   S   T   U   V