The nst Reference Manual

This is the nst Reference Manual, version 4.1.2, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 15:30:28 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 nst

The NST unit/regression testing system

Author

John Maraist <>

License

LLGPL 3.latest

Version

4.1.2

Dependencies
  • closer-mop (system).
  • org-sampler (system).
Source

nst.asd.

Child Component

core (module).


3 Modules

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


3.1 nst/core

Source

nst.asd.

Parent Component

nst (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 nst/nst.asd

Source

nst.asd.

Parent Component

nst (system).

ASDF Systems

nst.

Packages

nst-asd.

Internals

nst-doc (function).


4.1.2 nst/core/package.lisp

Source

nst.asd.

Parent Component

core (module).

Packages

4.1.3 nst/core/utils.lisp

Dependency

package.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Internals

4.1.4 nst/core/errors.lisp

Dependency

package.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Internals

4.1.5 nst/core/interrupt.lisp

Dependency

package.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Internals

4.1.6 nst/core/permuter.lisp

Dependency

package.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.7 nst/core/globals.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.8 nst/core/context.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Internals

4.1.9 nst/core/artifacts.lisp

Dependency

globals.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Packages

nst-name-usage.

Internals

4.1.10 nst/core/group.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface

def-test-group (macro).

Internals

4.1.11 nst/core/check.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.12 nst/core/fixture.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.13 nst/core/test-def.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface

def-test (macro).

Internals

4.1.14 nst/core/status.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.15 nst/core/runner.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Internals

4.1.16 nst/core/criteria.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Internals

4.1.17 nst/core/process.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.18 nst/core/command.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Packages

nst-artifact-lookup-package.

Public Interface

nst-cmd (macro).

Internals

4.1.19 nst/core/xml.lisp

Dependency

status.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Internals

4.1.20 nst/core/junit.lisp

Dependency

xml.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.21 nst/core/sampling.lisp

Dependency

check.lisp (file).

Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.22 nst/core/method.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Public Interface
Internals

4.1.23 nst/core/interfaces.lisp

Dependencies
Source

nst.asd.

Parent Component

core (module).

Packages

nst-control-api.

Internals

def-bundle-package (macro).


5 Packages

Packages are listed by definition order.


5.1 nst

Unit and regression testing for Common Lisp

Source

package.lisp.

Use List

common-lisp.

Public Interface
Internals

5.2 nst-artifact-lookup-package

Auxiliary package for canonical NST command names.

Source

command.lisp.


5.3 nst-control-api

API-level control of test execution and reporting.

Source

interfaces.lisp.


5.4 nst-name-usage

Source

artifacts.lisp.


5.5 nst-name-use-in-packages

Internal package for names’ record-keeping.

Source

package.lisp.


5.6 nst-asd

Source

nst.asd.

Use List
  • asdf/interface.
  • common-lisp.
Internals

nst-doc (function).


6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *assert-eq-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-eql-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-equal-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-equalp-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-nonnil-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-not-eq-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-not-eql-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-not-equal-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-not-equalp-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-null-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *assert-zero-format-string*
Package

nst.

Source

process.lisp.

Special Variable: *debug-on-error*

User variable =*debug-on-error*=: if non-nil, will break into the Lisp REPL debugger upon encountering an unexpected error. If nil, will record the error and continue with other tests.

Package

nst.

Source

globals.lisp.

Special Variable: *debug-on-fail*

User variable =*debug-on-fail*=: if non-nil, will break into the Lisp REPL debugger upon encountering a test which fails. If nil, will record the failure and continue with other tests. This variable is useful inspecting the dynamic environment under which a test was evaluated.

Package

nst.

Source

globals.lisp.

Special Variable: *default-report-verbosity*

User variable =*default-report-verbosity*= determines the default value for =*nst-verbosity*= when printing reports (2 by default).

Package

nst.

Source

globals.lisp.

Special Variable: *max-compound-structure-depth*

The =*max-compound-structure-depth*= variable sets the maximum nesting depth of compound data structures: beyond that depth, =scalar= rather than =t= is the default element generator. This restriction does not apply to explicitly specified element types, only to the use of defaults.

Package

nst.

Source

sampling.lisp.

Special Variable: *nst-output-stream*

Determines the output stream to which NST should print its output (=*standard-output*= by default).

Package

nst.

Source

globals.lisp.


6.1.2 Macros

Macro: assert-criterion (key-args criterion-expr &rest value-exprs)

The =assert-criterion= macro asserts that an NST criterion should pass. #+begin_example
(assert-criterion ( [ :msg-format FORMAT-STRING ]
[ :msg-args FORMAT-ARGUMENTS ]
[ :fatal FLAG [
[ :fail-on-warning FLAG ] )
FORM
...
FORM)
#+end_example
- msg-format :: Format string used to build the label of the restart point. - msg-args :: Format arguments used to build the label of the restart point. - fatal :: If non-nil, a failure of this assertion indicates that execution of the test forms should be aborted.
- fail-on-warning :: If non-nil, then an NST result which includes a warning indicates failure of this assertion.

Package

nst.

Source

process.lisp.

Macro: compound-structure (&body forms)

The =compound-structure= macro wraps substructure which should be considered compound for the limits set by =*max-compound-structure-depth*=.

Package

nst.

Source

sampling.lisp.

Macro: def-arbitrary-instance-type (type-expr &body technique)

New type specifications for invariant-testing. are defined with the =def-arbitrary-instance-type= macro.
#+begin_example
(def-arbitrary-instance-type ( SPEC-NAME [ :params FORMALS ]
[ :scalar BOOL ]
[ :key KEY ] )
FORM
FORM
...
FORM)
#+end_example
- =formals= :: Formal parameter definition used to pass subcomponent types. - =scalar= :: When a non-null value is provided for the =:scalar= argument, the new specifier is taken to be generable by the =:scalar= specification.
#+begin_example
(def-arbitrary-instance-type (ratio :scalar t)
(/ (arbitrary ’integer)
(let ((raw (arbitrary (find-class ’integer)))) (cond
((< raw 0) raw)
(t (+ 1 raw))))))
#+end_example
- =key= :: The =:key= argument gives a list of keyword arguments which may accompany the new specification. For the =cons= type, keyword arguments allow specifications for the left and right components: #+begin_example
(def-arbitrary-instance-type
(cons :key ((car t car-supp-p) (cdr t cdr-supp-p))) (compound-structure
(when (and (not car-supp-p)
(>= *current-compound-structure-depth* *max-compound-structure-depth*))
(setf car ’scalar))
(when (and (not cdr-supp-p)
(>= *current-compound-structure-depth* *max-compound-structure-depth*))
(setf cdr ’scalar))
(cons (arbitrary car) (arbitrary cdr)))) #+end_example
- =form= :: Construct and return (as if through =progn= the arbtrary instance.

Package

nst.

Source

sampling.lisp.

Macro: def-binary-negated-predicate-assert (assert-fn predicate default-message &rest keyargs &key message-defvar)

Macro =def-binary-negated-predicate-assert= uses the negated result of a binary predicate as the basis for an assertion function just as =def-unary-negated-predicate-assert= uses the negated result of a unary predicate. This macro’s arguments are just as for =def-unary-predicate-assert=.

Package

nst.

Source

process.lisp.

Macro: def-binary-predicate-assert (assert-fn predicate default-message &key message-defvar doc-state-flag pred-name)

Macro =def-binary-predicate-assert= uses a binary predicate as the basis for an assertion function just as =def-unary-predicate-assert= uses a unary predicate. This macro’s arguments are just as for =def-unary-predicate-assert=.

Package

nst.

Source

process.lisp.

Macro: def-criterion ((name args-formals values-formals) &body forms)

The =def-criterion= macro defines a new criterion for use in NST tests.
These criteria definitions are like generic function method definitions with two
sets of formal parameters: the forms provided as the actual parameters of the
criterion itself, and the values arising from the evaluation of the forms under
test.
#+begin_example
(def-criterion (name criterion-lambda-list values-lambda-list)
[ doc-string )
form
form
...
form)
#+end_example

- name :: Name of the criterion.
- criterion-lambda-list :: Lambda list for the arguments to the criterion. Optionally, the first element of the list is a symbol specifying the parameter-passing semantics for the criterion arguments: =:values= for call-by-value, or =:forms for call-by-name (the default). The list may include the keywords =&key=, =&optional=, =&body= and =&rest= but may not use =&whole= or =&environment=. Apart from this restriction, in the former case the list may be any ordinary lambda list as for =defun=, and in the latter case the list may be any macro lambda list as for =defmacro=.
- values-lambda-list :: Lambda list for the forms under test. Optionally, the first element of the list is a symbol specifying the parameter-passing semantics for the criterion arguments: :values for call-by-value (the default), or :form for call-by-name. In the former case, the list may include the keywords =&key=, =&optional=, =&body= and =&rest=, but not =&whole= or =&environment=; apart from that restriction, list may be any ordinary lambda list as for =defun=. In the latter case, the remainder of the list must contain exactly one symbol, to which a form which would evaluate to the values under test will be bound. If the criterion ignores the values, then instead of a lambda list, this argument may be the symbol =:ignore=. On many platforms, listing a dummy parameter which is then =declare=d =ignore= or =ignorable= will produce a style warning: the body of a =def-criterion= should not be assumed to correspond directly to the body of a =defmethod=; in general there will be surrounding =destructuring-bind=s.
- documentation :: An optional documentation string for the criterion.
- form :: The body of the criterion definition should return a test result report contructed with the =make-success-report=, etc. functions.
Examples:
#+begin_example
(def-criterion (:true () (bool))
(if bool
(make-success-report)
(make-failure-report :format "Expected non-null, got: ~s"
:args (list bool))))

(def-criterion (:eql (target) (actual))
(if (eql (eval target) actual)
(make-success-report)
(make-failure-report :format "Not eql to value of ~s"
:args (list target))))
#+end_example

Package

nst.

Source

check.lisp.

Macro: def-criterion-alias ((name . args-formals) docstring-or-form &optional form)

The simplest mechanism for defining a new criterion involves simply
defining one criterion to rewrite as another using =def-criterion-alias=. #+begin_example
(def-criterion-alias (name (:seq arg))
[ doc-string ]
expansion)
#+end_example
The body of the expansion should be a Lisp form which, when evaluated, returns an S-expression quoting the new criterion which the rewrite should produce. The =arg= are passed as for Lisp macros: they are not evaluated and are most typically comma-inserted into a backquoted result. For example: #+begin_example
(def-criterion-alias (:forms-eq) ‘(:predicate eq))
(def-criterion-alias (:symbol name) ‘(:eq ’,name))
#+end_example

Package

nst.

Source

check.lisp.

Macro: def-criterion-unevaluated ((name args-formals forms-formal &key ignore-forms) &body forms)

The =def-criterion-unevaluated= macro is deprecated as of NST 2.1.2. It was consolidated into the =def-criterion= macro.

Replace:
#+begin_example
(def-criterion-unevaluated name (pattern ... pattern) name
BODY)
#+end_example
with:
#+begin_example
(def-criterion name (:forms pattern ... pattern)
(:form name)
BODY)
#+end_example

Package

nst.

Source

check.lisp.

Macro: def-eval-test (name-or-name-and-args &rest forms)

The =def-eval-test= macro abbreviates a call to =def-test= with a single =:eval= criterion. Its arguments are just as for =def-test= and =:eval=. #+begin_example
(def-eval-test (NAME [ :group GROUP-NAME ]
[ :setup FORM ]
[ :cleanup FORM ]
[ :startup FORM ]
[ :finish FORM ]
[ :fixtures (FIXTURE ... FIXTURE) ]
[ :documentation STRING ]
[ :check-warnings FLAG ]
[ :muffle-warnings FLAG ]
[ :attempt-continue FLAG ]
[ :force-continue FLAG ] )
FORM
...
FORM)

(def-eval-test NAME
FORM
...
FORM)
#+end_example

Package

nst.

Source

process.lisp.

Macro: def-fixtures (name (&key uses assumes special outer inner documentation cache setup cleanup startup finish export-names export-bound-names export-fixture-name) &body bindings)

Fixtures are data structures and values which may be referred to by name during testing. NST provides the ability to use fixtures across multiple tests and test groups, and to inject fixtures into the runtime namespace for debugging. A set of fixtures is defined using the =def-fixtures= macro: #+begin_example
(def-fixtures fixture-name ( [ :outer FORM ]
[ :inner FORM ]
[ :setup FORM ]
[ :cleanup FORM ]
[ :startup FORM ]
[ :finish FORM ]
[ :documentation STRING ]
[ :cache FLAG ]
[ :export-names FLAG ]
[ :export-fixture-name FLAG ]
[ :export-bound-names FLAG ] )
( [ ( [ :cache FLAG ] ) ] NAME [ FORM ] )
...
( [ ( [ :cache FLAG ] ) ] NAME [ FORM ] ) )
#+end_example
- fixture-name :: The name to be associated with this set of fixtures.
- inner :: List of declarations to be made inside the let-binding of
names of any use of this fixture. Do not include the "declare" keyword here; NST adds these declarations to others, including a special declaration of all bound names.
- outer :: List of declarations to be made outside the let-binding of
names of any use of this fixture.
- documentation :: A documentation string for the fixture set.
- special :: Specifies a list of names which should be declared
=special= in the scope within which this set’s fixtures are
evaluated. The individual names are taken to be single variable names. Each =(:fixture NAME)= specifies all of the names of the given fixture set. This declaration is generally optional under most platforms, but can help supress spurious warnings. Note that
multiple =NAMEs= may be listed, and these lists and the bare
names may be intermixed. If only one name or fixture is
specified, it need not be placed in a list
- export-fixture-name :: When non-nil, the fixture name will be added
to the list of symbols exported by the current package.
- export-bound-names :: When non-nil, the names bound by this fixture
will be added to the list of symbols exported by the current package.
- export-names :: When non-nil, sets the default value to t for the
two options above.
- cache :: If specified with the group options, when non-nil, the
fixture values are cached at their first use, and re-applied at subsequent fixture application rather than being recalculated.

When a fixture is attached to a test or test group, each =NAME=
defined in that fixture becomes available in the body of that test or
group as if =let*= bound to the corresponding =FORM=. A fixture in
one set may refer back to other fixtures in the same set (again as
=let*=) but forward references are not allowed.

The four arguments =startup=, =finish=, =setup= and =cleanup= specify
forms which are run everytime the fixture is applied to a group or
test. The =startup= (respectively =finish=) form is run before
fixtures are bound (after their bindings are released). These forms
are useful, for example, to initialize a database connection from
which the fixture values are drawn. The =setup= form is run after inclusion of names from fixture sets, but before any tests from the
group. The =cleanup= form is normally run after the test completes,
but while the fixtures are still in scope. Normally, the =cleanup=
form will not be run if the =setup= form raises an error, and the
=finish= form will not be run if the =startup= form raises an error; although the user is able to select (perhaps unwisely) a restart which disregards the error.

The names of a fixture and the names it binds can be exported from the package where the fixture is defined using the =export-bound-names=
and =export-fixture-name= arguments. The default value of both is the value of =export-names=, whose default value is =nil=.

The =cache= option, if non-nil, directs NST to evaluate a fixture’s
form one single time, and re-use the resulting value on subsequent applications of the fixture. Note that if this value is mutated by
the test cases, test behavior may become unpredictable! However this option can considerably improve performance when constant-valued
fixtures are applied repeatedly. Caching may be set on or off (the
default is off) for the entire fixture set, and the setting may vary
for individual fixtures.

Examples of fixture definitions:
#+begin_example
(def-fixtures f1 ()
(c 3)
(d ’asdfg))
(def-fixtures f2 (:special ((:fixture f1)))
(d 4)
(e ’asdfg)
(f c))
(def-fixtures f3 ()
((:cache t) g (ackermann 1 2))
((:cache nil) h (factorial 5)))
#+end_example

To cause a side-effect among the evaluation of a fixture’s name definitions, =nil= can be provided as a fixture name. In uses of the fixture, NST will replace =nil= with a non-interned symbol; in documentation such as form =:whatis=, any =nil=s are omitted.

Package

nst.

Source

fixture.lisp.

Macro: def-form-criterion ((name args-formals form-formal) &rest forms)

The =def-form-criterion= macro was deprecated as of NST 1.3.0. /Code using =def-form-criterion= in any but the simplest ways is very likely to fail./ Use =def-criterion= instead.

Package

nst.

Source

check.lisp.

Macro: def-test (name-or-name-and-args criterion &rest forms)

Individual unit tests are encoded with the =def-test= form: #+begin_example
(def-test NAME ( [ :group GROUP-NAME ]
[ :setup FORM ]
[ :cleanup FORM ]
[ :startup FORM ]
[ :finish FORM ]
[ :fixtures (FIXTURE FIXTURE ... FIXTURE) ]
[ :aspirational FLAG ]
[ :documentation STRING ] )
criterion
FORM ... FORM)

(def-test NAME criterion &body (:seq FORM))
#+end_example
The =SETUP=, =CLEANUP=, =STARTUP=, =FINISH= and =FIXTURES= are just as for fixtures and test groups, but apply only to the one test. The =CRITERION= is a list or symbol specifying the properties which should hold for
the =FORM=s.

When a test is not enclosed within a group body, a group name must be provided by the =GROUP= option. When a test is enclosed within
a group body, the =GROUP= option is not required, but if
provided it must agree with the group name.

When there are no =SETUP=, =CLEANUP=, =STARTUP=, =FINISH= or =FIXTURES= arguments, the =NAME= may be given without parentheses. Likewise, any criterion consisting of a single symbol, e.g. =(:pass)=, may be abbreviated as just the symbol without the parentheses, e.g. =:pass=.

The =:documentation= form provides a documentation string in
the standard Lisp sense. Since documentation strings are stored
against names, and since the same name can be used for several tests
(so long as they are all in different packages), documentation strings
on tests may not be particularly useful.

An =aspirational= test is one which verifies some part of an API or code contract which may not yet be implemented. When a group is marked aspirational, all tests within the group are taken to be aspirational as well. At this point, there is no particular processing for aspirational tests and groups, but we hope to implement it at some point in the future.

The =def-check= form is a deprecated synonym for =def-test=.

Package

nst.

Source

test-def.lisp.

Macro: def-test-generic (function-name &body forms)

The =def-test-generic= declares a generic test function. #+begin_example
(def-test-generic FUNCTION-NAME)
#+end_example
For example,
#+begin_example
(nst:def-test-generic for-clses)
#+end_example

Package

nst.

Source

method.lisp.

Macro: def-test-group (group-name given-fixtures &body forms)

The =def-test-group= form defines a group of the
given name, providing one instantiation of the bindings of the given fixtures
to each test. Groups can be associated with fixture sets, stateful
initialization, and stateful cleanup.
#+begin_example
(def-test-group NAME (FIXTURE FIXTURE ...)
(:aspirational FLAG)
(:setup FORM FORM ... FORM)
(:cleanup FORM FORM ... FORM)
(:startup FORM FORM ... FORM)
(:finish FORM FORM ... FORM)
(:each-setup FORM FORM ... FORM)
(:each-cleanup FORM FORM ... FORM)
(:include-groups GROUP GROUP ... GROUP)
(:documentation STRING)
TEST
...
TEST)
#+end_example
Arguments:
- group-name :: Name of the test group being defined
- given-fixtures :: List of the names of fixtures and anonymous fixtures to be used with the tests in this group.
- aspirational :: An aspirational test is one which verifies some part of an API or code contract which may not yet be implemented. When a group is marked aspirational, all tests within the group are taken to be aspirational as well. At this point, there is no particular processing for aspirational tests and groups, but we hope to implement it at some point in the future.
- forms :: Zero or more test forms, given by =def-check=.
- setup :: These forms are run once, before any of the individual tests, but after the fixture names are bound.
- cleanup :: These forms are run once, after all of the individual tests, but while the fixture names are still bound.
- startup :: These forms are run once, before any of the individual tests and before the fixture names are bound.
- finish :: These forms are run once, after all of the individual tests, and after the scope of the bindings to fixture names.
- each-setup :: These forms are run before each individual test.
- each-cleanup :: These forms are run after each individual test.
- include-group :: The test groups named in this form will be run (respectively reported) anytime this group is run (reported).
- documentation :: Docstring for the class.

Package

nst.

Source

group.lisp.

Macro: def-test-method (function-name (arg class) &body body)

The =def-test-method= defines a general method for a generic test function. #+begin_example
(def-test-method FUNCTION-NAME (TEST-VALUE CLASS-NAME)
FORM
...
FORM)
#+end_example
- function-name :: The name of the test function for which we are defining a method.
- test-value :: Formal parameter to which the value under test will be bound. - class-name :: The class for which we are defining a method.
The method body should return a test result report, constructed with =make-success-result=, etc.
For example:
#+begin_example
(nst:def-test-method for-clses (o mid-cls)
(with-slots (mc1 mc2) o
(cond
((< mc1 mc2) (make-success-report))
(t (make-failure-report :format "~d not < ~d" :args (list mc1 mc2)))))) (nst:def-test-method for-clses (o side-cls)
(with-slots (sc1 sc2) o
(cond
((eql sc1 sc2) (make-success-report))
(t (make-failure-report :format "~d not eql ~d" :args (list sc1 sc2)))))) #+end_example

Package

nst.

Source

method.lisp.

Macro: def-test-method-criterion (function-name class documentation &optional criterion)

The =def-test-method-criterion= macro provides a simple facility for defining a generic test function method in terms of an NST criterion. #+begin_example
(def-test-method-criterion FUNCTION-NAME CLASS-NAME [ CRITERION ] )
#+end_example
- function-name :: The name of the test function for which we are defining a
method.
- class-name :: The class for which we are defining a method.
- criterion :: The criterion to be applied to members of the class.
For example:
#+begin_example
(nst:def-test-method-criterion for-clses top-cls
(:predicate (lambda (tc) (< (tc1 tc) (tc2 tc)))))
#+end_example

Package

nst.

Source

method.lisp.

Macro: def-unary-negated-predicate-assert (assert-fn predicate default-message &rest keyargs &key message-defvar)

Macro =def-unary-negated-predicate-assert= uses the negated result of a unary predicate as the basis of an assertion function. This macro’s arguments are just as for =def-unary-predicate-assert=.

Package

nst.

Source

process.lisp.

Macro: def-unary-predicate-assert (assert-fn predicate default-message &key message-defvar doc-state-flag pred-name &allow-other-keys)

Macro =macro def-unary-predicate-assert= creates an assertion function using
the result of a call to a unary predicate. A non-nil result from the predicate
corresponds to a successful assertion.
#+begin_example
(def-unary-predicate-assert ASSERT-FN PREDICATE DEFAULT-MESSAGE
[ :message-defvar NAME ]
[ :pred-name NAME ]
[ :doc-state-flag BOOL ] )
#+end_example
- assert-fn :: The name of the assertion function being defined.
- predicate :: The predicate used to define the assertion function. It should take a single argument.
- default-message :: Format string used by default for reporting failures of this assertion. It should expect to be used in a call to =format= with one additional argument, the value being tested. - message-defvar :: The name of a global variable into which the default message will be stored. If this argument is omitted, the result of a call to =gensym= is used.
- pred-name :: This argument is used only for documenting the underlying predicate in the assertion function’s docstring. By default, it is the same as the predicate.

Package

nst.

Source

process.lisp.

Macro: def-values-criterion ((name args-formals forms-formals &key declare) &body forms)

The =def-values-criterion= macro was deprecated as of NST 1.3.0. For new criteria, use =def-criterion= instead. In the short term, code using =def-values-criterion= should continue to work as before.

Package

nst.

Source

check.lisp.

Macro: emit-failure (&rest args)

The =emit-failure= function is deprecated; use =make-failure-report= instead.

Package

nst.

Source

status.lisp.

Macro: emit-success (&rest args)

The =emit-success= function is deprecated; use =make-success-report= instead.

Package

nst.

Source

status.lisp.

Macro: emit-warning (&rest args)

The =emit-warning= function is deprecated; use =make-warning-report= instead.

Package

nst.

Source

status.lisp.

Macro: nst-cmd (&rest args)

User-level NST operations are accessible from the REPL via the =nst-cmd= macro.
#+begin_example
(nst-cmd NST-COMMAND ARG ... ARG)
#+end_example
Where a particular system supports the facility (Currently Allegro, and SBCL under ACL-REPL) the top-level alias =:nst= provides a shorthand to this function.

Package

nst.

Source

command.lisp.

Macro: with-fixtures ((&rest fixtures) &body forms)

The =with-fixtures= macro faciliates debugging and other non-NST uses of fixtures sets:
#+begin_example
(with-fixtures (FIXTURE FIXTURE ... FIXTURE)
FORM
FORM
...
FORM)
#+end_example
This macro evaluates the forms in a namespace expanded with the bindings provided by the fixtures.

Package

nst.

Source

fixture.lisp.


6.1.3 Ordinary functions

Function: add-error (result &key format args)

For use within user-defined NST criteria: add an error to a result. #+begin_example
(add-error RESULT-REPORT [ :format FORMAT-STRING ] [ :args ARGUMENT-LIST ] ) #+end_example

Package

nst.

Source

status.lisp.

Function: add-failure (result &key format args)

For use within user-defined NST criteria: add a failure to a result. #+begin_example
(add-failure RESULT-REPORT [ :format FORMAT-STRING ] [ :args ARGUMENT-LIST ]) #+end_example

Package

nst.

Source

status.lisp.

Function: add-info (result item)

For use within user-defined NST criteria: add an info note to a result. #+begin_example
(add-info RESULT-REPORT INFO-ITEM)
#+end_example

Package

nst.

Source

status.lisp.

Function: assert-eq (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-EQ= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQ=, succeeds whenever that call returns non-nil.

Package

nst.

Source

process.lisp.

Function: assert-eql (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-EQL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQL=, succeeds whenever that call returns non-nil.

Package

nst.

Source

process.lisp.

Function: assert-equal (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-EQUAL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQUAL=, succeeds whenever that call returns non-nil.

Package

nst.

Source

process.lisp.

Function: assert-equalp (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-EQUALP= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQUALP=, succeeds whenever that call returns non-nil.

Package

nst.

Source

process.lisp.

Function: assert-non-nil (g0 &rest g1 &key format format-args fatal &allow-other-keys)

The =ASSERT-NON-NIL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It succeeds whenever the =NULL= function returns =nil=.

Package

nst.

Source

process.lisp.

Function: assert-not-eq (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-NOT-EQ= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQ=, succeeds whenever that call returns =nil=.

Package

nst.

Source

process.lisp.

Function: assert-not-eql (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-NOT-EQL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQL=, succeeds whenever that call returns =nil=.

Package

nst.

Source

process.lisp.

Function: assert-not-equal (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-NOT-EQUAL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQUAL=, succeeds whenever that call returns =nil=.

Package

nst.

Source

process.lisp.

Function: assert-not-equalp (g0 g1 &rest g2 &key format format-args fatal &allow-other-keys)

The =ASSERT-NOT-EQUALP= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It compares the expected and tested values using =EQUALP=, succeeds whenever that call returns =nil=.

Package

nst.

Source

process.lisp.

Function: assert-null (g0 &rest g1 &key format format-args fatal &allow-other-keys)

The =ASSERT-NULL= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It succeeds whenever the =NULL= function returns non-nil.

Package

nst.

Source

process.lisp.

Function: assert-zero (g0 &rest g1 &key format format-args fatal &allow-other-keys)

The =ASSERT-ZERO= function is a unary predicate for use within the forms evaluated for an =:eval= criterion. It succeeds whenever the =ZEROP= function returns non-nil.

Package

nst.

Source

process.lisp.

Function: check-criterion-on-form (criterion form)

This function verifies that the values return by evaluating the form adheres to the criterion.
#+begin_example
(check-criterion-on-form CRITERION FORM)
#+end_example

Package

nst.

Source

check.lisp.

Function: check-criterion-on-value (criterion val)

The =check-criterion-on-value= function can be called from within a criterion body to verify that a value adheres to a criterion.
#+begin_example
(check-criterion-on-value CRITERION VALUE)
#+end_example

Package

nst.

Source

check.lisp.

Function: junit-results-by-group (&rest args &key verbose &allow-other-keys)

The \texttt{junit-results-by-group} function writes the NST test results in JUnit XML format, organized by group, aligning test groups with Java classes, and individual tests with \texttt{@Test} methods. #+begin_example
(junit-results-by-group [ :verbose FLAG ]
[ :dir DIRECTORY ]
[ :file FILESPEC ]
[ :stream STREAM ]
[ :if-dir-does-not-exist BOOL ]
[ :if-file-exists BOOL ] )
#+end_example
Either =:dir= and =:file= options, or the =:stream= option, but not both, should
e used to specify the target for XML output; if none of the three options are
given, the function will write to =*standard-output*=.

Package

nst.

Source

junit.lisp.

Function: make-error-report (e &rest format-args)

Function =make-error-report= produces a report of an error during test execution. #+begin_example
(make-error-report [ :format FORMAT-STRING ] [ :args ARG-FORM-LIST ] ) #+end_example

Package

nst.

Source

status.lisp.

Function: make-failure-report (&key format args info)

The =make-failure-report= function returns a report of test failure. #+begin_example
(make-failure-report FORMAT ARGS)
#+end_example
The =format-string= and =args= are as to the Common Lisp function =format=. The =emit-failure= function is an older, deprecated version of this function.

Package

nst.

Source

status.lisp.

Function: make-success-report (&rest args &key warnings info skipped)

The =make-success-report= function indicates a successful test result. #+begin_example
(make-success-report)
#+end_example
Note that some older examples show =(make-check-result)=, =(emit-success)= or =(check-result)=. The former is an internal function and should not be used from outside the core NST files. The latter two are deprecated.

Package

nst.

Source

status.lisp.

Function: make-warning-report (&key format args)

Function =make-warning-report= is like =make-failure-report=, but provides supplimentary information as a warning.
#+begin_example
(make-warning-report [ :format FORMAT-STRING ] [ :args ARG-FORM-LIST ]) #+end_example
The =emit-warning= function is an older, deprecated version of this function.

Package

nst.

Source

status.lisp.

Function: wrap-thrown-lisp-warning (w)

The helper function =wrap-thrown-lisp-warning= creates an NST =check-note= object from a standard Lisp =warning=.

Package

nst.

Source

status.lisp.


6.1.4 Generic functions

Generic Function: add-warning (result w &rest args)

For use within user-defined NST criteria: add a warning to a
result.

The =add-warning= function adds an warning to a result record. The item can be any of a Lisp warning, an NST check-note or a format string; in the first two cases, no additional arguments should be provided.
#+begin_example
(add-warning RESULT-REPORT [ :format ITEM ] [ :args ARGUMENT-LIST ] ) #+end_example

Package

nst.

Source

status.lisp.

Methods
Method: add-warning (result (format-string string) &rest args)
Method: add-warning (result (w check-note) &rest args)
Method: add-warning (result (w warning) &rest args)
Generic Function: arbitrary (typ)

This function takes a single argument, which determines the
type of the value to be generated. For simple types, the name of the type (or the class object, such as returned by =find-class= by itself is a complete specification. For more complicated types, =arbitrary= can also take a list argument, where the first element gives the type and the remaining elements are keyword argument providing additional requirements for the generated value.

Package

nst.

Source

sampling.lisp.

Methods
Method: arbitrary ((spec cons))
Method: arbitrary (other)
Generic Function: nst-junit-dump (stream)

Function =nst-junit-dump= pushes the entire NST state to a JUnit XML file whose stream is specified by its argument.

Package

nst.

Source

junit.lisp.

Methods
Method: nst-junit-dump ((filename string))

Write the results of this session’s NST testing in JUnit XML format.

Method: nst-junit-dump ((stream stream))

6.1.5 Standalone methods

Writer Method: (setf class-name) ((method-context-layer method-context-layer))

automatically generated writer method

Source

method.lisp.

Target Slot

class-name.

Reader Method: class-name ((method-context-layer method-context-layer))

automatically generated reader method

Source

method.lisp.

Target Slot

class-name.

Method: initialize-instance :after ((p permuter) &key src &allow-other-keys)
Source

permuter.lisp.

Method: print-object ((p permuter) stream)
Source

permuter.lisp.


6.1.6 Method combinations

Method Combination: nst-results (&optional order)

NST defines a method combination =nst-results= as the default
method combination for functions defined by =def-test-generic=. This combination runs /all/ applicable methods, and combines all of their results into a single NST result record.

This default can be overridden by specifying =t= as the method combination in the intial declaration.
#+begin_example
(nst:def-test-generic overridden (:method-combination t)) (nst:def-test-method-criterion overridden mid-cls
(:slots (mc1 (:eql 0))
(mc2 (:eql 2))))
(nst:def-test-method-criterion overridden bot-cls
(:slots (sc1 (:eql 1))
(sc2 (:eql 1))))

Package

nst.

Source

method.lisp.

Operator

check-result-union (function).

Identity with one argument

nil


6.2 Internals


6.2.1 Constants

Constant: +keyboard-interrupt-class+

Name of the class of error thrown when a keyboard interrupt is received, or nil if this implementation of Lisp has no such class.

Package

nst.

Source

interrupt.lisp.


6.2.2 Special variables

Special Variable: *char-escapes*
Package

nst.

Source

junit.lisp.

Special Variable: *current-compound-structure-depth*
Package

nst.

Source

sampling.lisp.

Special Variable: *default-character-range*
Package

nst.

Source

sampling.lisp.

Special Variable: *default-debug-config*

User variable: the default setting applied by default. Should be a list of alternating keyword/forms matching:
- nst-set - list of lists, each with arguments to :nst :set
- progn - list of forms to be evaluated

Package

nst.

Source

globals.lisp.

Special Variable: *default-debug-protect*
Package

nst.

Source

globals.lisp.

Special Variable: *default-xml-pprint-dispatch*
Package

nst.

Source

xml.lisp.

Special Variable: *entities*
Package

nst.

Source

junit.lisp.

Special Variable: *fixture-bindings*

Map implementing FIXTURE-BINDINGS: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Special Variable: *fixture-letlist*

Map implementing FIXTURE-LETLIST: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Special Variable: *fixture-record*

Map implementing FIXTURE-RECORD: from fixture name to its =fixture-record=

Package

nst.

Source

fixture.lisp.

Special Variable: *generate-backtraces*

User variable: if non-null, will attempt to capture the Lisp backtrace of errors in tests.

Package

nst.

Source

globals.lisp.

Special Variable: *group-records*

Primary storage of group and test records; this level of map translates from group name to an instance of =group-record=.

Package

nst.

Source

group.lisp.

Special Variable: *implicit-group-choice*
Package

nst.

Source

runner.lisp.

Special Variable: *last-repl-call*
Package

nst.

Source

command.lisp.

Special Variable: *max-auto-array-rank*
Package

nst.

Source

sampling.lisp.

Special Variable: *nst-check-internal-name*

Dynamic variable used to set the name of a test in its result report.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-check-user-name*

Dynamic variable used to set the name of a test in its result report.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-context*

Dynamic-scoped variable recording the values under test - a list of context-layer instances.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-context-evaluable*

Dynamic-scoped variable tracking whether the values under test should be asusmed evaluated. Used in preparing context expressions.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-debug*

User variable: apply customizable debugging settings.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-group-name*

Dynamic variable used to set the name of the group in a test result report.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-group-shown*

Dynamic-scoped variable tracking whether the name of a group has been printed, so that tests need not repeat it.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-report-driver*

Dynamic-scoped variable - one of :multiple, :package, :group or :test to determine the top-level form of a report. Used as a control parameter for printing reports.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-stack*

Dynamic-scoped variable - the stack of values under test by the current criterion.

Package

nst.

Source

globals.lisp.

Special Variable: *nst-verbosity*

User variable determining how verbose NST’s output to the REPL should be. Internally, this variable takes an integer value: 0 and below are silent, 1 is the default, 2 and 3 are more verbose, and 4 is for full tracing. The command-line interpreter assigns keywords to these values, from most terse to most verbose: :silent, nil, :quiet, :default, t, :verbose, :vverbose (:quiet and :default are the same, and are the initial setting).

Package

nst.

Source

globals.lisp.

Special Variable: *test-methods*

Global variable for programmer-defined NST test methods.

Package

nst.

Source

method.lisp.

Special Variable: +arbitrary-generable-types+
Package

nst.

Source

sampling.lisp.

Special Variable: +name-uses+

Map from a symbol in the =:nst-name-usage= package to a =name-use= instance decribing how a symbol of the same name is used for NST artifacts.

Package

nst.

Source

artifacts.lisp.

Special Variable: +nst-repl-commands+
Package

nst.

Source

command.lisp.

Special Variable: +nst-repl-properties+
Package

nst.

Source

command.lisp.

Special Variable: +results-record+

Results of test runs.

Package

nst.

Source

artifacts.lisp.

Special Variable: +scalar-generable-types+
Package

nst.

Source

sampling.lisp.

Special Variable: qw
Package

nst.

Source

permuter.lisp.

Special Variable: qwerty
Package

nst.

Source

permuter.lisp.


6.2.3 Macros

Macro: apply-debug-options (forms-spec protect-vars &body forms)
Package

nst.

Source

globals.lisp.

Macro: apply-default-debug-options (&body forms)
Package

nst.

Source

globals.lisp.

Macro: at-verbosity (lv &body forms)
Package

nst.

Source

globals.lisp.

Macro: check-result (&rest args)
Package

nst.

Source

status.lisp.

Macro: coin-flip (&rest outcomes)
Package

nst.

Source

sampling.lisp.

Macro: count-nonnulls (&rest bools)
Package

nst.

Source

status.lisp.

Macro: def-bundle-package (name repackaging &body forms)
Package

nst.

Source

interfaces.lisp.

Macro: def-check (&rest args)
Package

nst.

Source

test-def.lisp.

Macro: def-check-alias (&rest args)

Deprecated: use def-criterion-alias instead

Package

nst.

Source

check.lisp.

Macro: def-control-check (&rest args)

Deprecated: use def-criterion instead

Package

nst.

Source

check.lisp.

Macro: def-hashtable-fns (fn (&key test global) &optional docstring)
Package

nst.

Source

utils.lisp.

Macro: def-nst-interactive-command ((name &key short-help long-help long-help-special args repeatable) &body forms)
Package

nst.

Source

command.lisp.

Macro: def-nst-property (name variable &key doc filter unfilter)
Package

nst.

Source

command.lisp.

Macro: def-value-check (&rest args)

Deprecated: use def-criterion instead

Package

nst.

Source

check.lisp.

Macro: define-nst-error (name fields (stream exp) &body printer)
Package

nst.

Source

errors.lisp.

Macro: emit-error (&rest args)

Deprecated; use make-success-report.

Package

nst.

Source

status.lisp.

Macro: format-at-verbosity (lv format &rest args)
Package

nst.

Source

globals.lisp.

Macro: handler-bind-interruptable (handlers &body forms)

Like handler-bind (and the arguments are similar), but cancel any error- handling if the error is related to a keyboard interrupt.

Package

nst.

Source

interrupt.lisp.

Macro: log10 (v)
Package

nst.

Source

utils.lisp.

Macro: named-function (name lambda-expression)
Package

nst.

Source

utils.lisp.

Macro: protect-nst-config (&body forms)
Package

nst.

Source

globals.lisp.

Macro: returning-criterion-config-error ((msg) &body forms)

For use within criteria definitions only — catch errors and process them as errors in the "glue" among criteria and forms.

Package

nst.

Source

check.lisp.

Macro: returning-test-error (&body forms)

For use within criteria definitions only — catch errors and process them as errors arising from within the .

Package

nst.

Source

check.lisp.

Macro: with-context-layer (layer-expr &body body)
Package

nst.

Source

context.lisp.

Macro: with-criterion-context-layer ((&rest layer-args) &body body)
Package

nst.

Source

context.lisp.

Macro: with-method-context-layer ((method-name class-name object) &body body)
Package

nst.

Source

method.lisp.

Macro: with-nst-control-handlers (((formal flag &key for-fail for-error cerror-label-var cerror-label with-retry post-cerror group tests fail-test-msg log-location handler-return-to handler-return) &body handler) &body body)

Macro for inserting restarts at points in the NST test-running stack.

Package

nst.

Source

errors.lisp.

Macro: with-output-for-verbosity ((lv stream-name) &body forms)
Package

nst.

Source

globals.lisp.

Macro: with-pprint-cdata ((stream-name) &body forms)
Package

nst.

Source

xml.lisp.

Macro: with-retry ((continuation-label) &body forms)
Package

nst.

Source

errors.lisp.

Macro: with-xml-tagged-pprint-logical-block ((stream tag &key properties) &body forms)
Package

nst.

Source

xml.lisp.


6.2.4 Ordinary functions

Function: %make-check-result (&key tests passing erring failing warning elapsed-time timestamp group-name check-name warnings failures errors skipped info)
Package

nst.

Source

status.lisp.

Function: add-thrown-error (result e &rest format-args)
Package

nst.

Source

status.lisp.

Function: all-groups-report ()
Package

nst.

Source

status.lisp.

Function: all-package-report ()
Package

nst.

Source

status.lisp.

Function: all-tests-report ()
Package

nst.

Source

status.lisp.

Function: all-uses (name)

Return the list of group- and test-records, and possibly also a Lisp package object, corresponding to possible intended targets of an NST run.

Package

nst.

Source

artifacts.lisp.

Function: apply-check-note-formatter (stream check-note)
Package

nst.

Source

status.lisp.

Function: apply-fixture (fixture next-fixtures group-record test-records body-thunk)
Package

nst.

Source

fixture.lisp.

Function: apply-fixtures (fixtures group-record test-records body-thunk)
Package

nst.

Source

fixture.lisp.

Function: apply-formatter (stream formatter args)
Package

nst.

Source

status.lisp.

Function: arbitrary-generable-types ()
Package

nst.

Source

sampling.lisp.

Function: artifact-recorder (symbol)
Package

nst.

Source

artifacts.lisp.

Function: assemble-protected-option-values (other-vars)
Package

nst.

Source

globals.lisp.

Function: assert-criterion-fn (criterion-expr values-form &key msg-format msg-args fatal fail-on-warning)
Package

nst.

Source

process.lisp.

Function: blurb-one-name-use (stream name entity item enumerate)
Package

nst.

Source

artifacts.lisp.

Function: build-continue-check-expr (criterion form)
Package

nst.

Source

check.lisp.

Function: calibrate-check-result (r)
Package

nst.

Source

status.lisp.

Function: cdr-or-nil (name-or-name-and-args)

Return the cdr given a list, or return nil if given a symbol.

Package

nst.

Source

utils.lisp.

Reader: check-note-args (instance)
Writer: (setf check-note-args) (instance)
Package

nst.

Source

status.lisp.

Target Slot

args.

Reader: check-note-context (instance)
Writer: (setf check-note-context) (instance)
Package

nst.

Source

status.lisp.

Target Slot

context.

Reader: check-note-format (instance)
Writer: (setf check-note-format) (instance)
Package

nst.

Source

status.lisp.

Target Slot

format.

Function: check-note-p (object)
Package

nst.

Source

status.lisp.

Reader: check-note-stack (instance)
Writer: (setf check-note-stack) (instance)
Package

nst.

Source

status.lisp.

Target Slot

stack.

Reader: check-result-check-name (instance)
Writer: (setf check-result-check-name) (instance)
Package

nst.

Source

status.lisp.

Target Slot

check-name.

Function: check-result-elapsed-time (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-elapsed-time) (instance)
Package

nst.

Source

status.lisp.

Function: check-result-erring (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-erring) (instance)
Package

nst.

Source

status.lisp.

Reader: check-result-errors (instance)
Writer: (setf check-result-errors) (instance)
Package

nst.

Source

status.lisp.

Target Slot

errors.

Function: check-result-failing (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-failing) (instance)
Package

nst.

Source

status.lisp.

Reader: check-result-failures (instance)
Writer: (setf check-result-failures) (instance)
Package

nst.

Source

status.lisp.

Target Slot

failures.

Reader: check-result-group-name (instance)
Writer: (setf check-result-group-name) (instance)
Package

nst.

Source

status.lisp.

Target Slot

group-name.

Reader: check-result-info (instance)
Writer: (setf check-result-info) (instance)
Package

nst.

Source

status.lisp.

Target Slot

info.

Function: check-result-p (object)
Package

nst.

Source

status.lisp.

Function: check-result-passing (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-passing) (instance)
Package

nst.

Source

status.lisp.

Reader: check-result-skipped (instance)
Writer: (setf check-result-skipped) (instance)
Package

nst.

Source

status.lisp.

Target Slot

skipped.

Reader: check-result-tests (instance)
Writer: (setf check-result-tests) (instance)
Package

nst.

Source

status.lisp.

Target Slot

tests.

Function: check-result-timestamp (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-timestamp) (instance)
Package

nst.

Source

status.lisp.

Function: check-result-union (&rest reports)
Package

nst.

Source

method.lisp.

Function: check-result-warning (instance)
Package

nst.

Source

status.lisp.

Function: (setf check-result-warning) (instance)
Package

nst.

Source

status.lisp.

Reader: check-result-warnings (instance)
Writer: (setf check-result-warnings) (instance)
Package

nst.

Source

status.lisp.

Target Slot

warnings.

Function: collect-test-generics (obj)
Package

nst.

Source

method.lisp.

Function: continue-check (criterion form)
Package

nst.

Source

check.lisp.

Function: copy-check-note (instance)
Package

nst.

Source

status.lisp.

Function: copy-check-result (instance)
Package

nst.

Source

status.lisp.

Function: copy-error-check-note (instance)
Package

nst.

Source

status.lisp.

Function: copy-fixture-record (instance)
Package

nst.

Source

fixture.lisp.

Function: copy-group-record (instance)
Package

nst.

Source

group.lisp.

Function: copy-group-result (instance)
Package

nst.

Source

status.lisp.

Function: copy-multi-results (instance)
Package

nst.

Source

status.lisp.

Function: copy-name-use (instance)
Package

nst.

Source

artifacts.lisp.

Function: copy-package-result (instance)
Package

nst.

Source

status.lisp.

Function: copy-result-stats (instance)
Package

nst.

Source

artifacts.lisp.

Function: copy-test-record (instance)
Package

nst.

Source

test-def.lisp.

Function: core-run-test (test)

Capture the result of the test.

Package

nst.

Source

runner.lisp.

Function: decode-caching-decls (fixture-name binding-specs all-cache)

Process a list of binding specifications to extract both the bindings, and the local variables needed for caching.

Package

nst.

Source

fixture.lisp.

Function: decode-def-test-generic-body (forms)
Package

nst.

Source

method.lisp.

Function: decode-defcheck-name-and-args (name-or-name-and-args)

This function unpacks the information inside the first form of a def-test block, which can be either a single symbol naming the test, or a list whose first element is that symbol and whose remaining elements are options.

Package

nst.

Source

test-def.lisp.

Function: decode-fixture-syntax (fixture-name binding-specs decls outer-decls setup cleanup startup finish cache specials use-fixtures special-variables)

Assemble syntactic elements of a fixture into the fixture function and the list of names defined by the fixture.

Package

nst.

Source

fixture.lisp.

Function: decompose-arg-values-lambda-list (args-formals)
Package

nst.

Source

check.lisp.

Function: elapsed-time-to-string (elapsed-time)
Package

nst.

Source

xml.lisp.

Function: eql-for-sigdigits (digits n1 n2)

Test whether two numbers are eql to the given number of significant digits.

Package

nst.

Source

utils.lisp.

Function: error-check-note-args (instance)
Package

nst.

Source

status.lisp.

Function: (setf error-check-note-args) (instance)
Package

nst.

Source

status.lisp.

Function: error-check-note-context (instance)
Package

nst.

Source

status.lisp.

Function: (setf error-check-note-context) (instance)
Package

nst.

Source

status.lisp.

Reader: error-check-note-error (instance)
Writer: (setf error-check-note-error) (instance)
Package

nst.

Source

status.lisp.

Target Slot

error.

Function: error-check-note-format (instance)
Package

nst.

Source

status.lisp.

Function: (setf error-check-note-format) (instance)
Package

nst.

Source

status.lisp.

Function: error-check-note-p (object)
Package

nst.

Source

status.lisp.

Function: error-check-note-stack (instance)
Package

nst.

Source

status.lisp.

Function: (setf error-check-note-stack) (instance)
Package

nst.

Source

status.lisp.

Function: executable-uses (name)

Return the list of group- and test-records, and possibly also a Lisp package object, corresponding to possible intended targets of an NST run.

Package

nst.

Source

artifacts.lisp.

Function: extract-parameters (x)
Package

nst.

Source

check.lisp.

Function: finish-multiple-report (result)
Package

nst.

Source

status.lisp.

Function: fixture-binding-error-note (fixture-name variable-name error)
Package

nst.

Source

status.lisp.

Function: fixture-bindings (name)

Reader function: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Function: (setf fixture-bindings) (name)

Writer function: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Function: fixture-letlist (name)

Reader function: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Function: (setf fixture-letlist) (name)

Writer function: from fixture name to the list of local variable names bound that fixture

Package

nst.

Source

fixture.lisp.

Function: fixture-record (name)

Reader function: from fixture name to its =fixture-record=

Package

nst.

Source

fixture.lisp.

Function: (setf fixture-record) (name)

Writer function: from fixture name to its =fixture-record=

Package

nst.

Source

fixture.lisp.

Reader: fixture-record-bindings-list (instance)
Writer: (setf fixture-record-bindings-list) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

bindings-list.

Reader: fixture-record-bound-names (instance)
Writer: (setf fixture-record-bound-names) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

bound-names.

Reader: fixture-record-cache-flush (instance)
Writer: (setf fixture-record-cache-flush) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

cache-flush.

Reader: fixture-record-documentation (instance)
Writer: (setf fixture-record-documentation) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

documentation.

Reader: fixture-record-function (instance)
Writer: (setf fixture-record-function) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

function.

Reader: fixture-record-name (instance)
Writer: (setf fixture-record-name) (instance)
Package

nst.

Source

fixture.lisp.

Target Slot

name.

Function: fixture-record-p (object)
Package

nst.

Source

fixture.lisp.

Function: flag-filter (x)
Package

nst.

Source

command.lisp.

Function: flush-fixture-cache (name)
Package

nst.

Source

fixture.lisp.

Function: generate-sample (domains)
Package

nst.

Source

sampling.lisp.

Function: get-display-context-layers (layers)
Package

nst.

Source

context.lisp.

Function: get-local-criterion-context (context-layer-list)
Package

nst.

Source

context.lisp.

Function: get-report-from-names (group-or-package gp-supp-p test test-supp-p)
Package

nst.

Source

status.lisp.

Function: get-test-record-specials (test-record)
Package

nst.

Source

runner.lisp.

Function: get-unassigned (p)
Package

nst.

Source

permuter.lisp.

Function: group-record (name)
Package

nst.

Source

group.lisp.

Function: (setf group-record) (name)
Package

nst.

Source

group.lisp.

Reader: group-record-anon-fixture-forms (instance)
Writer: (setf group-record-anon-fixture-forms) (instance)
Package

nst.

Source

group.lisp.

Target Slot

anon-fixture-forms.

Reader: group-record-aspirational (instance)
Writer: (setf group-record-aspirational) (instance)
Package

nst.

Source

group.lisp.

Target Slot

aspirational.

Reader: group-record-documentation (instance)
Writer: (setf group-record-documentation) (instance)
Package

nst.

Source

group.lisp.

Target Slot

documentation.

Reader: group-record-eachtest-cleanup-thunk (instance)
Writer: (setf group-record-eachtest-cleanup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

eachtest-cleanup-thunk.

Reader: group-record-eachtest-setup-thunk (instance)
Writer: (setf group-record-eachtest-setup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

eachtest-setup-thunk.

Reader: group-record-fixtures-cleanup-thunk (instance)
Writer: (setf group-record-fixtures-cleanup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

fixtures-cleanup-thunk.

Reader: group-record-fixtures-setup-thunk (instance)
Writer: (setf group-record-fixtures-setup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

fixtures-setup-thunk.

Reader: group-record-given-fixtures (instance)
Writer: (setf group-record-given-fixtures) (instance)
Package

nst.

Source

group.lisp.

Target Slot

given-fixtures.

Reader: group-record-include-groups (instance)
Writer: (setf group-record-include-groups) (instance)
Package

nst.

Source

group.lisp.

Target Slot

include-groups.

Reader: group-record-name (instance)
Writer: (setf group-record-name) (instance)
Package

nst.

Source

group.lisp.

Target Slot

name.

Function: group-record-p (object)
Package

nst.

Source

group.lisp.

Reader: group-record-tests (instance)
Writer: (setf group-record-tests) (instance)
Package

nst.

Source

group.lisp.

Target Slot

tests.

Reader: group-record-withfixtures-cleanup-thunk (instance)
Writer: (setf group-record-withfixtures-cleanup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

withfixtures-cleanup-thunk.

Reader: group-record-withfixtures-setup-thunk (instance)
Writer: (setf group-record-withfixtures-setup-thunk) (instance)
Package

nst.

Source

group.lisp.

Target Slot

withfixtures-setup-thunk.

Function: group-report (group)

Top-level function for reporting the results of a group.

Package

nst.

Source

status.lisp.

Reader: group-result-check-results (instance)
Writer: (setf group-result-check-results) (instance)
Package

nst.

Source

status.lisp.

Target Slot

check-results.

Function: group-result-elapsed-time (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-elapsed-time) (instance)
Package

nst.

Source

status.lisp.

Function: group-result-erring (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-erring) (instance)
Package

nst.

Source

status.lisp.

Function: group-result-failing (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-failing) (instance)
Package

nst.

Source

status.lisp.

Reader: group-result-group-name (instance)
Writer: (setf group-result-group-name) (instance)
Package

nst.

Source

status.lisp.

Target Slot

group-name.

Function: group-result-p (object)
Package

nst.

Source

status.lisp.

Function: group-result-passing (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-passing) (instance)
Package

nst.

Source

status.lisp.

Function: group-result-tests (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-tests) (instance)
Package

nst.

Source

status.lisp.

Function: group-result-timestamp (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-timestamp) (instance)
Package

nst.

Source

status.lisp.

Function: group-result-warning (instance)
Package

nst.

Source

status.lisp.

Function: (setf group-result-warning) (instance)
Package

nst.

Source

status.lisp.

Function: interesting-result-p (result)
Package

nst.

Source

status.lisp.

Function: invoke-test-methods (obj)
Package

nst.

Source

method.lisp.

Function: junit-header (stream)
Package

nst.

Source

xml.lisp.

Function: low-biased-natnum (&optional bias)
Package

nst.

Source

sampling.lisp.

Function: make-and-calibrate-check-result (&rest args)
Package

nst.

Source

status.lisp.

Function: make-check-note (&key context stack format args)
Package

nst.

Source

status.lisp.

Function: make-check-result (&key group-name check-name warnings failures errors info tests passing erring failing warning skipped elapsed-time timestamp)

Functional wrapper around the constructor for =check-result= structure, permitting the use of apply.

Package

nst.

Source

status.lisp.

Function: make-config-error (error group-record test-record msg)
Package

nst.

Source

status.lisp.

Function: make-error-check-note (&key context stack format args error)
Package

nst.

Source

status.lisp.

Function: make-error-note (e &rest format-args)
Package

nst.

Source

status.lisp.

Function: make-fixture-record (&key name function bound-names bindings-list documentation cache-flush)
Package

nst.

Source

fixture.lisp.

Function: make-group-record (&key name anon-fixture-forms aspirational given-fixtures documentation tests fixtures-setup-thunk fixtures-cleanup-thunk withfixtures-setup-thunk withfixtures-cleanup-thunk eachtest-setup-thunk eachtest-cleanup-thunk include-groups)
Package

nst.

Source

group.lisp.

Function: make-group-result (&key tests passing erring failing warning elapsed-time timestamp group-name check-results)
Package

nst.

Source

status.lisp.

Function: make-multi-results (&key tests passing erring failing warning elapsed-time timestamp package-reports group-reports test-reports system stats-source)
Package

nst.

Source

status.lisp.

Function: make-name-use (&key name fixtures groups tests package-p last-use)
Package

nst.

Source

artifacts.lisp.

Function: make-package-result (&key tests passing erring failing warning elapsed-time timestamp package-name group-results)
Package

nst.

Source

status.lisp.

Function: make-result-stats (&key tests passing erring failing warning elapsed-time timestamp)
Package

nst.

Source

artifacts.lisp.

Function: make-skipped-report (&key format args)

Function =make-skipped-report= is like =make-failure-report=, but provides supplimentary information as a skipped.
#+begin_example
(make-skipped-report [ :format FORMAT-STRING ] [ :args ARG-FORM-LIST ]) #+end_example
The =emit-skipped= function is an older, deprecated version of this function.

Package

nst.

Source

status.lisp.

Function: make-test-record (&key name group fixtures criterion forms special-fixture-names documentation setup cleanup startup finish results aspirational aspirational-supp)
Package

nst.

Source

test-def.lisp.

Function: mid-biased-natnum (mid &optional bias)
Package

nst.

Source

sampling.lisp.

Function: multi-results-elapsed-time (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-elapsed-time) (instance)
Package

nst.

Source

status.lisp.

Function: multi-results-erring (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-erring) (instance)
Package

nst.

Source

status.lisp.

Function: multi-results-failing (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-failing) (instance)
Package

nst.

Source

status.lisp.

Reader: multi-results-group-reports (instance)
Writer: (setf multi-results-group-reports) (instance)
Package

nst.

Source

status.lisp.

Target Slot

group-reports.

Function: multi-results-p (object)
Package

nst.

Source

status.lisp.

Reader: multi-results-package-reports (instance)
Writer: (setf multi-results-package-reports) (instance)
Package

nst.

Source

status.lisp.

Target Slot

package-reports.

Function: multi-results-passing (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-passing) (instance)
Package

nst.

Source

status.lisp.

Reader: multi-results-stats-source (instance)
Writer: (setf multi-results-stats-source) (instance)
Package

nst.

Source

status.lisp.

Target Slot

stats-source.

Reader: multi-results-system (instance)
Writer: (setf multi-results-system) (instance)
Package

nst.

Source

status.lisp.

Target Slot

system.

Reader: multi-results-test-reports (instance)
Writer: (setf multi-results-test-reports) (instance)
Package

nst.

Source

status.lisp.

Target Slot

test-reports.

Function: multi-results-tests (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-tests) (instance)
Package

nst.

Source

status.lisp.

Function: multi-results-timestamp (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-timestamp) (instance)
Package

nst.

Source

status.lisp.

Function: multi-results-warning (instance)
Package

nst.

Source

status.lisp.

Function: (setf multi-results-warning) (instance)
Package

nst.

Source

status.lisp.

Function: multiple-report (packages groups tests &key system)
Package

nst.

Source

status.lisp.

Function: name-use (symbol &optional no-create)
Package

nst.

Source

artifacts.lisp.

Reader: name-use-fixtures (instance)
Writer: (setf name-use-fixtures) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

fixtures.

Reader: name-use-groups (instance)
Writer: (setf name-use-groups) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

groups.

Reader: name-use-last-use (instance)
Writer: (setf name-use-last-use) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

last-use.

Reader: name-use-name (instance)
Writer: (setf name-use-name) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

name.

Function: name-use-p (object)
Package

nst.

Source

artifacts.lisp.

Reader: name-use-package-p (instance)
Writer: (setf name-use-package-p) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

package-p.

Reader: name-use-tests (instance)
Writer: (setf name-use-tests) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

tests.

Function: next-permutation (p)
Package

nst.

Source

permuter.lisp.

Function: no-effect ()
Package

nst.

Source

utils.lisp.

Function: note-name-invocation (what)
Package

nst.

Source

artifacts.lisp.

Function: nst-doc ()
Package

nst-asd.

Source

nst.asd.

Function: nst-dump (&key stream verbosity)

Spit out the full NST state.

Package

nst.

Source

status.lisp.

Function: nst-xml-dump (stream)
Package

nst.

Source

junit.lisp.

Function: open-fixture (name &optional in-package)

Push the bindings from a fixture into a package’s namespace.

Package

nst.

Source

fixture.lisp.

Function: package-groups (package-or-symbol)

Return the groups whose name is a symbol in the given package.

Package

nst.

Source

group.lisp.

Function: package-report (&optional package)

Top-level function for reporting the results of a package.

Package

nst.

Source

status.lisp.

Function: package-result-elapsed-time (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-elapsed-time) (instance)
Package

nst.

Source

status.lisp.

Function: package-result-erring (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-erring) (instance)
Package

nst.

Source

status.lisp.

Function: package-result-failing (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-failing) (instance)
Package

nst.

Source

status.lisp.

Reader: package-result-group-results (instance)
Writer: (setf package-result-group-results) (instance)
Package

nst.

Source

status.lisp.

Target Slot

group-results.

Function: package-result-p (object)
Package

nst.

Source

status.lisp.

Reader: package-result-package-name (instance)
Writer: (setf package-result-package-name) (instance)
Package

nst.

Source

status.lisp.

Target Slot

package-name.

Function: package-result-passing (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-passing) (instance)
Package

nst.

Source

status.lisp.

Function: package-result-tests (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-tests) (instance)
Package

nst.

Source

status.lisp.

Function: package-result-timestamp (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-timestamp) (instance)
Package

nst.

Source

status.lisp.

Function: package-result-warning (instance)
Package

nst.

Source

status.lisp.

Function: (setf package-result-warning) (instance)
Package

nst.

Source

status.lisp.

Function: pick-from-sequence (seq)
Package

nst.

Source

sampling.lisp.

Function: pprint-cdata-string (stream string)
Package

nst.

Source

xml.lisp.

Function: pprint-xml (object &optional stream)
Package

nst.

Source

xml.lisp.

Function: princ-filled-text (string &optional stream)
Package

nst.

Source

globals.lisp.

Function: pull-test-name-list (form)

Given syntax of the form (DEF-CHECK ...) or (DEF-TEST ...), pull the name of the test from the syntax.

Package

nst.

Source

group.lisp.

Function: record-name-use (record)

Store the use of a name (as given by a fixture-, group-, or test-record) in the index.

Package

nst.

Source

artifacts.lisp.

Function: record-package-use (base-name)
Package

nst.

Source

artifacts.lisp.

Function: refine-package-symbol-desigs (package-desig symbol-desig)
Package

nst.

Source

criteria.lisp.

Function: relax-stack (p)
Package

nst.

Source

permuter.lisp.

Function: report-details (group-or-package gp-supp-p test test-supp-p)
Package

nst.

Source

status.lisp.

Function: report-group (group &optional stream *nst-verbosity*)

Top-level function for reporting the results of the tests in a group.

Package

nst.

Source

status.lisp.

Function: report-interesting ()
Package

nst.

Source

status.lisp.

Function: report-multiple (packages groups tests &key stream verbosity system)

Top-level function for reporting the results of several tests.

Package

nst.

Source

status.lisp.

Function: report-package (&optional package stream *nst-verbosity*)

Top-level function for reporting the results of the tests in a package.

Package

nst.

Source

status.lisp.

Function: report-summary (group-or-package gp-supp-p test test-supp-p)
Package

nst.

Source

status.lisp.

Function: report-test (group test &optional stream *nst-verbosity*)

Top-level function for reporting the results of a test.

Package

nst.

Source

status.lisp.

Function: restore-protected-option-values (stored-values)
Package

nst.

Source

globals.lisp.

Reader: result-stats-elapsed-time (instance)
Writer: (setf result-stats-elapsed-time) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

elapsed-time.

Reader: result-stats-erring (instance)
Writer: (setf result-stats-erring) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

erring.

Reader: result-stats-failing (instance)
Writer: (setf result-stats-failing) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

failing.

Function: result-stats-p (object)
Package

nst.

Source

artifacts.lisp.

Reader: result-stats-passing (instance)
Writer: (setf result-stats-passing) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

passing.

Reader: result-stats-tests (instance)
Writer: (setf result-stats-tests) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

tests.

Reader: result-stats-timestamp (instance)
Writer: (setf result-stats-timestamp) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

timestamp.

Reader: result-stats-warning (instance)
Writer: (setf result-stats-warning) (instance)
Package

nst.

Source

artifacts.lisp.

Target Slot

warning.

Function: run-debug-options (options-form)
Package

nst.

Source

globals.lisp.

Function: run-group (group-name)

Run a group by its user-given name. Note that this is /not/ an interactive function — certain behaviors provided by e.g. the ASDF extension or REPL macros require the dynamic configuration provided by those wrappers.

Package

nst.

Source

runner.lisp.

Function: run-group-record (group-record)
Package

nst.

Source

runner.lisp.

Function: run-group-test (group-record test-record)
Package

nst.

Source

runner.lisp.

Function: run-group-tests (group-record test-records)

Programmatic entry point for running all tests in a group.

Package

nst.

Source

runner.lisp.

Function: run-group-tests-fixtures-thunk (group-record test-records)
Package

nst.

Source

runner.lisp.

Function: run-nst-command (&rest args)
Package

nst.

Source

command.lisp.

Function: run-package (&optional package-or-name)

Run all groups in a package. Note that this is /not/ an interactive function — certain behaviors provided by e.g. the ASDF extension or REPL macros require the dynamic configuration provided by those wrappers.

Package

nst.

Source

runner.lisp.

Function: run-test (group-name test-name)

Run a test standalone by its user-given name (and its group’s name). Note that this is /not/ an interactive function — certain behaviors provided by e.g. the ASDF extension or REPL macros require the dynamic configuration provided by those wrappers.

Package

nst.

Source

runner.lisp.

Function: run-test-fixtures-thunk (group-record test-record)
Package

nst.

Source

runner.lisp.

Function: run-test-inst (test-record)
Package

nst.

Source

runner.lisp.

Function: separate-group-subforms (forms)

Given a list of forms, separate and decode the option specifiers from any test forms. Returns many results:
- The list of test forms, in the same order as originally given.
- The =setup= option forms, and a flag set if the option was present.
- The =cleanup= option forms, and a flag set if the option was present. - The =startup= option forms, and a flag set if the option was present. - The =finish= option forms, and a flag set if the option was present.
- The =each= option forms, and a flag set if the option was present.
- The =each-cleanup= option forms, and a flag set if the option was present. - The =docstring=, or nil if none was given.
- The =aspirational= flag, and a flag set if it was present.
- The =include-groups= list, and a flag set if it was present.

Package

nst.

Source

group.lisp.

Function: sig-place (n value)

Returns the n-th significant place of value

Package

nst.

Source

utils.lisp.

Function: soft-dep-warning (prefix cnd stream)
Package

nst.

Source

errors.lisp.

Function: string-escaped (string)
Package

nst.

Source

junit.lisp.

Function: symbol-or-car (name-or-name-and-args)

Return the first element given a list, or return a symbol.

Package

nst.

Source

utils.lisp.

Function: symbol-to-junit-name (symbol)
Package

nst.

Source

xml.lisp.

Function: test-is-aspirational (test-record)

Check both the test and group record to see if a test should be considered aspirational.

Package

nst.

Source

test-def.lisp.

Function: test-record (group test)
Package

nst.

Source

group.lisp.

Function: (setf test-record) (group test)
Package

nst.

Source

group.lisp.

Reader: test-record-aspirational (instance)
Writer: (setf test-record-aspirational) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

aspirational.

Reader: test-record-aspirational-supp (instance)
Writer: (setf test-record-aspirational-supp) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

aspirational-supp.

Reader: test-record-cleanup (instance)
Writer: (setf test-record-cleanup) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

cleanup.

Reader: test-record-criterion (instance)
Writer: (setf test-record-criterion) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

criterion.

Reader: test-record-documentation (instance)
Writer: (setf test-record-documentation) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

documentation.

Reader: test-record-finish (instance)
Writer: (setf test-record-finish) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

finish.

Reader: test-record-fixtures (instance)
Writer: (setf test-record-fixtures) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

fixtures.

Reader: test-record-forms (instance)
Writer: (setf test-record-forms) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

forms.

Reader: test-record-group (instance)
Writer: (setf test-record-group) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

group.

Reader: test-record-name (instance)
Writer: (setf test-record-name) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

name.

Function: test-record-p (object)
Package

nst.

Source

test-def.lisp.

Reader: test-record-results (instance)
Writer: (setf test-record-results) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

results.

Reader: test-record-setup (instance)
Writer: (setf test-record-setup) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

setup.

Reader: test-record-special-fixture-names (instance)
Writer: (setf test-record-special-fixture-names) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

special-fixture-names.

Reader: test-record-startup (instance)
Writer: (setf test-record-startup) (instance)
Package

nst.

Source

test-def.lisp.

Target Slot

startup.

Function: test-report (group test)

Top-level function for reporting the results of a test.

Package

nst.

Source

status.lisp.

Function: tighten-stack (p slottable)
Package

nst.

Source

permuter.lisp.

Function: timestamp-to-string (timestamp)
Package

nst.

Source

xml.lisp.

Function: trace-results ()

Internal debugging function: dump the results hash.

Package

nst.

Source

artifacts.lisp.

Function: use-stats-from (stats-source stats-dest)
Package

nst.

Source

status.lisp.

Function: whittlable (pf)
Package

nst.

Source

permuter.lisp.

Function: whittle-relaxed-stack (p)
Package

nst.

Source

permuter.lisp.

Function: wrap-fixture-name-specials (fixture-names-special form)
Package

nst.

Source

runner.lisp.


6.2.5 Generic functions

Generic Reader: actual-value (condition)
Package

nst.

Methods
Reader Method: actual-value ((condition not-expected-form))
Source

errors.lisp.

Target Slot

actual-value.

Generic Function: apply-criterion (top args form)

Internal generic function whose methods are the translations of criteria.

Package

nst.

Source

check.lisp.

Methods
Method: apply-criterion ((top (eql :methods)) args0 values-form1)
Source

method.lisp.

Method: apply-criterion ((top (eql :sample)) args0 g1)

Invariants to be tested, and the domains over which they range, are specified with the =:sample= criterion:
#+begin_example
(def-criterion ( [ :verify FORM ]
[ :value LAMBDA-LIST ]
[ :domains ((NAME SPEC) ... (NAME SPEC)) ]
[ :where FORM ]
[ :where-ignore (NAME ... NAME) ]
[ :where-declare (DECLARATION ... DECLARATION) ]
[ :sample-size NUMBER ]
[ :qualifying-sample NUMBER ]
[ :max-tries NUMBER ] ) )
#+end_example
- =:verify= :: The expression to be (repeatedly) evaluated, which is expected always to return a non-null value. This is the sole required argument, although in any particular use it is unlikely to be the only argument given.
- =:domains= :: The variables in the =verify= expression which are to be given multiple randomized values. The default value is =nil=, denoting an empty list.
- =:value= :: A lambda list to which the values given by the argument form should be applied. The default value is =nil=, denoting no such arguments.
- =:where= :: A condition which determines the validity of the input argument. For example, the condition would assert that a number is positive in an application where a negative value would be known to cause a failure. The default value is =t=, allowing any values.
- =:where-ignore= :: List of domain variables which are not mentioned in the =where= clause. These names will be declared as ignored in appropriate bindings, suppressing warnings under Lisps which check for such things in interpreted expressions. This list need not be given explicitly when no =where= argument is given. Similarly, the =where-declare= argument accepts a list of declarations to be associated with the =where= form.
- =:sample-size= :: Gives the base specification of the number of value sets which will be generated. Two further arguments have some bearing on the number of generation attempts when the =where= argument is non =t=. The =qualifying-sample= argument gives the minimum acceptable size of actual tested values, not counting sets rejected via the =where= expression. The =max-tries= argument gives the maximum number of value sets to be generated.
Examples:
#+begin_example
(:sample :sample-size 10
:domains ((x (list :elem symbol)))
:verify (equal x (reverse (reverse x))))
#+end_example
#+begin_example
(:sample :domains ((x real))
:where (> x 1)
:verify (< (sqrt x) x)
:sample-size 10
:max-tries 12)
#+end_example

Source

sampling.lisp.

Method: apply-criterion ((top (eql :process)) args0 g1)
Source

process.lisp.

Method: apply-criterion ((top (eql :eval)) args0 forms-list)
Source

process.lisp.

Method: apply-criterion ((top (eql :with-common-criterion)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :applying-common-criterion)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :package-internal)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :package-exports)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :slots)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :across)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :permute)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :alist)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :alist*)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :seq)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :each)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :values)) args0 form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :proj)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :progn)) args0 forms)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :check-err)) args0 forms)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :apply)) args0 exprs-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :any)) args0 expr-list-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :all)) args0 expr-list-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :not)) args0 expr-list-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :perf)) args0 expr-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :err)) args0 expr-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :info)) args0 expr-list-form)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :dump-forms)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :drop-values)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :predicate)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :value-list)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :forms-equal)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :forms-eql)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :forms-eq)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :equalp)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :equal)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :eql)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :symbol)) args1 form0)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :eq)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :true)) args0 values-form1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :true-form)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :warn)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :skip)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :fail)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion ((top (eql :pass)) args0 g1)
Source

criteria.lisp.

Method: apply-criterion :around (top args form)
Generic Function: arbitrary-by-spec (name &key test size key val existing gensym exported nonnull package rank dimens elem car cdr length noncontrol range &allow-other-keys)

Return an arbitrary value according to a spec

Package

nst.

Source

sampling.lisp.

Methods
Method: arbitrary-by-spec ((g0 (eql #<structure-class common-lisp:hash-table>)) &key test size key val)
Method: arbitrary-by-spec ((l (eql #<built-in-class common-lisp:symbol>)) &key existing gensym exported nonnull package)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:array>)) &key rank dimens elem)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:cons>)) &key car cdr)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:list>)) &key elem length)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:string>)) &key noncontrol range)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:vector>)) &key elem length)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:character>)) &key noncontrol range)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:complex>)) &key)
Method: arbitrary-by-spec ((g0 (eql long-float)) &key)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:double-float>)) &key)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:single-float>)) &key)
Method: arbitrary-by-spec ((g0 (eql short-float)) &key)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:ratio>)) &key)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:bignum>)) &key)
Method: arbitrary-by-spec ((g0 (eql #<built-in-class common-lisp:fixnum>)) &key)
Method: arbitrary-by-spec ((g0 (eql nst::scalar)) &key)
Method: arbitrary-by-spec ((n (eql #<built-in-class common-lisp:float>)) &key)
Method: arbitrary-by-spec ((n (eql #<built-in-class common-lisp:integer>)) &key)
Method: arbitrary-by-spec ((n (eql #<built-in-class common-lisp:rational>)) &key)
Method: arbitrary-by-spec ((n (eql #<built-in-class common-lisp:real>)) &key)
Method: arbitrary-by-spec ((n (eql #<built-in-class common-lisp:number>)) &key)
Method: arbitrary-by-spec (unknown &rest keyword-args)
Method: arbitrary-by-spec ((other-named-spec symbol) &rest keyword-args &key &allow-other-keys)
Method: arbitrary-by-spec ((any (eql #<sb-pcl:system-class common-lisp:t>)) &key)
Generic Function: arbitrary-grounded-type (bound)

Return an arbitrary type bounded by the given type.

Package

nst.

Source

sampling.lisp.

Methods
Method: arbitrary-grounded-type ((s symbol))
Method: arbitrary-grounded-type ((s (eql #<sb-pcl:system-class common-lisp:t>)))
Method: arbitrary-grounded-type ((s (eql #<built-in-class common-lisp:symbol>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:number>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:real>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:rational>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:integer>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:fixnum>)))
Method: arbitrary-grounded-type ((n (eql bignum)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:ratio>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:float>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:single-float>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:double-float>)))
Method: arbitrary-grounded-type ((n (eql #<built-in-class common-lisp:complex>)))
Generic Reader: assertion-failure-args (condition)
Package

nst.

Methods
Reader Method: assertion-failure-args ((condition nst-assertion-failure))
Source

process.lisp.

Target Slot

args.

Generic Reader: assertion-failure-fatal (condition)
Package

nst.

Methods
Reader Method: assertion-failure-fatal ((condition nst-assertion-condition))
Source

process.lisp.

Target Slot

fatal.

Generic Reader: assertion-failure-formatter (condition)
Package

nst.

Methods
Reader Method: assertion-failure-formatter ((condition nst-assertion-failure))
Source

process.lisp.

Target Slot

formatter.

Generic Function: base-name (record)

Return a symbol naming the record

Package

nst.

Source

globals.lisp.

Methods
Method: base-name ((test-record test-record))
Source

test-def.lisp.

Method: base-name ((fixture-record fixture-record))
Source

fixture.lisp.

Method: base-name ((group-record group-record))
Source

group.lisp.

Method: base-name (record)

By default, return =nil= for a non-indexable artifact.

Method: base-name ((package package))
Generic Function: check-note-type-string (type context)
Package

nst.

Source

status.lisp.

Methods
Method: check-note-type-string (type (context (eql :xml)))
Source

xml.lisp.

Method: check-note-type-string (type context)
Generic Function: consider-repl-call-save (name args)
Package

nst.

Source

command.lisp.

Methods
Method: consider-repl-call-save ((cmd (eql :run)) args)
Method: consider-repl-call-save ((cmd (eql :run-test)) args)
Method: consider-repl-call-save ((cmd (eql :run-group)) args)
Method: consider-repl-call-save ((cmd (eql :run-package)) args)
Method: consider-repl-call-save ((cmd (eql :open)) args)
Method: consider-repl-call-save (name args)
Generic Reader: criterion (object)
Package

nst.

Methods
Reader Method: criterion ((criterion-context-layer criterion-context-layer))

automatically generated reader method

Source

context.lisp.

Target Slot

criterion.

Generic Writer: (setf criterion) (object)
Package

nst.

Methods
Writer Method: (setf criterion) ((criterion-context-layer criterion-context-layer))

automatically generated writer method

Source

context.lisp.

Target Slot

criterion.

Generic Reader: criterion-args (object)
Package

nst.

Methods
Reader Method: criterion-args ((criterion-context-layer criterion-context-layer))

automatically generated reader method

Source

context.lisp.

Target Slot

criterion-args.

Generic Writer: (setf criterion-args) (object)
Package

nst.

Methods
Writer Method: (setf criterion-args) ((criterion-context-layer criterion-context-layer))

automatically generated writer method

Source

context.lisp.

Target Slot

criterion-args.

Generic Reader: criterion-name (condition)
Package

nst.

Methods
Reader Method: criterion-name ((condition criterion-missing-mandatory-argument))
Source

errors.lisp.

Target Slot

criterion-name.

Generic Reader: domain (condition)
Package

nst.

Methods
Reader Method: domain ((condition unknown-arbitrary-domain))
Source

sampling.lisp.

Target Slot

domain.

Generic Reader: expected-form (condition)
Package

nst.

Methods
Reader Method: expected-form ((condition not-expected-form))
Source

errors.lisp.

Target Slot

expected-form.

Generic Function: fmt-permuter (stream p)
Package

nst.

Source

permuter.lisp.

Methods
Method: fmt-permuter (stream (p permuter))
Method: fmt-permuter (stream (pf permuter-frame))
Generic Function: format-for-warning (stream item colon at-sign &rest params)

Hook allowing us to sometimes do better than the usual pretty-printer for warnings.

Package

nst.

Source

status.lisp.

Methods
Method: format-for-warning (stream item colon at-sign &rest params)
Generic Reader: given-stack (object)
Package

nst.

Methods
Reader Method: given-stack ((criterion-context-layer criterion-context-layer))

automatically generated reader method

Source

context.lisp.

Target Slot

given-stack.

Generic Writer: (setf given-stack) (object)
Package

nst.

Methods
Writer Method: (setf given-stack) ((criterion-context-layer criterion-context-layer))

automatically generated writer method

Source

context.lisp.

Target Slot

given-stack.

Generic Reader: group (condition)
Package

nst.

Methods
Reader Method: group ((condition no-such-nst-test))
Source

errors.lisp.

Target Slot

group.

Reader Method: group ((condition no-such-nst-group))
Source

errors.lisp.

Target Slot

group.

Generic Reader: has-next (object)
Package

nst.

Methods
Reader Method: has-next ((permuter permuter))

automatically generated reader method

Source

permuter.lisp.

Target Slot

has-next.

Generic Function: junit-group-result (group &rest args &key dir file verbose stream if-dir-does-not-exist if-file-exists)
Package

nst.

Source

junit.lisp.

Methods
Method: junit-group-result ((group group-result) &rest args &key verbose dir file stream if-dir-does-not-exist if-file-exists)
Method: junit-group-result ((group symbol) &rest args &key dir file verbose stream if-dir-does-not-exist if-file-exists)
Generic Reader: keyword-args (condition)
Package

nst.

Methods
Reader Method: keyword-args ((condition unknown-arbitrary-domain))
Source

sampling.lisp.

Target Slot

keyword-args.

Generic Reader: method-name (object)
Package

nst.

Methods
Reader Method: method-name ((method-context-layer method-context-layer))

automatically generated reader method

Source

method.lisp.

Target Slot

method-name.

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

nst.

Methods
Writer Method: (setf method-name) ((method-context-layer method-context-layer))

automatically generated writer method

Source

method.lisp.

Target Slot

method-name.

Generic Function: nst-arg-names (command)

Return a string giving help for the argument names for an ~ NST REPL command.

Package

nst.

Source

command.lisp.

Methods
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::apply)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::whatis)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::unset)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::set)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::clear)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::detail)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::report)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::run)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::run-test)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::run-group)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::run-package)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::open)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::debug)))
Method: nst-arg-names ((cmd (eql nst-artifact-lookup-package::help)))
Method: nst-arg-names (command)
Generic Reader: nst-assertion-result (condition)
Package

nst.

Methods
Reader Method: nst-assertion-result ((condition nst-assertion-result-check))
Source

process.lisp.

Target Slot

result.

Generic Function: nst-long-help (command)

Return the long help message for an NST REPL command.

Package

nst.

Source

command.lisp.

Methods
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::apply)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::whatis)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::unset)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::set)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::clear)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::detail)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::report)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::run)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::run-test)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::run-group)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::run-package)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::open)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::debug)))
Method: nst-long-help ((cmd (eql nst-artifact-lookup-package::help)))
Method: nst-long-help (command)
Generic Function: nst-repl-property-display (n)

Return the display value of an NST property’s internal value.

Package

nst.

Source

globals.lisp.

Methods
Method: nst-repl-property-display ((n (eql :verbose)))
Source

command.lisp.

Method: nst-repl-property-display ((n (eql :debug-on-fail)))
Source

command.lisp.

Method: nst-repl-property-display ((n (eql :debug-on-error)))
Source

command.lisp.

Generic Function: nst-repl-property-doc (n)

Return the documentation string of an NST property.

Package

nst.

Source

globals.lisp.

Methods
Method: nst-repl-property-doc ((n (eql :verbose)))
Source

command.lisp.

Method: nst-repl-property-doc ((n (eql :debug-on-fail)))
Source

command.lisp.

Method: nst-repl-property-doc ((n (eql :debug-on-error)))
Source

command.lisp.

Generic Function: nst-repl-property-encode (prop val)

Encode an NST property’s display value as an internal value.

Package

nst.

Source

globals.lisp.

Methods
Method: nst-repl-property-encode ((n (eql :verbose)) value)
Source

command.lisp.

Method: nst-repl-property-encode ((n (eql :debug-on-fail)) value)
Source

command.lisp.

Method: nst-repl-property-encode ((n (eql :debug-on-error)) value)
Source

command.lisp.

Generic Function: nst-short-help (command)

Return the short help message for an NST REPL command.

Package

nst.

Source

command.lisp.

Methods
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::apply)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::whatis)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::unset)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::set)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::clear)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::detail)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::report)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::run)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::run-test)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::run-group)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::run-package)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::open)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::debug)))
Method: nst-short-help ((cmd (eql nst-artifact-lookup-package::help)))
Method: nst-short-help (command)
Generic Reader: object (object)
Package

nst.

Methods
Reader Method: object ((method-context-layer method-context-layer))

automatically generated reader method

Source

method.lisp.

Target Slot

object.

Generic Writer: (setf object) (object)
Package

nst.

Methods
Writer Method: (setf object) ((method-context-layer method-context-layer))

automatically generated writer method

Source

method.lisp.

Target Slot

object.

Generic Reader: old-name (condition)
Package

nst.

Methods
Reader Method: old-name ((condition nst-deprecation-warning-mixin))
Source

errors.lisp.

Target Slot

old-name.

Generic Reader: package-of (condition)
Package

nst.

Methods
Reader Method: package-of ((condition no-nst-groups-in-package))
Source

errors.lisp.

Target Slot

package.

Generic Function: prep-arg-names-help (arg-list)

This function formats the lambda list of an
NST REPL command for display in the online-help system. The macro def-nst-interactive-command that expands a REPL command definition into the underlying Lisp defmethods uses this function to generate the bodies of the help-related methods, so this function must be available from compile-time forward.

Package

nst.

Source

command.lisp.

Methods
Method: prep-arg-names-help (arg-list)
Generic Reader: replacement (condition)
Package

nst.

Methods
Reader Method: replacement ((condition nst-deprecation-warning-mixin))
Source

errors.lisp.

Target Slot

replacement.

Generic Reader: required-keyarg (condition)
Package

nst.

Methods
Reader Method: required-keyarg ((condition criterion-missing-mandatory-argument))
Source

errors.lisp.

Target Slot

required-keyarg.

Generic Function: result-summary (report &optional code total passed erred failed warned other)

Receives a reporting structure (or list of them); returns a six-value summary of the results:
- A symbol, one of: :error :fail :warn :info :clear
- The total number of named checks.
- The number passed.
- The number raising an error.
- The number failing.
- The number giving a warning.

Package

nst.

Source

status.lisp.

Methods
Method: result-summary ((rs null) &optional code total passed erred failed warned other)
Method: result-summary ((rs cons) &optional code total passed erred failed warned other)
Method: result-summary ((r multi-results) &optional code total passed erred failed warned other)
Method: result-summary ((r package-result) &optional code total passed erred failed warned other)
Method: result-summary ((r group-result) &optional code total passed erred failed warned other)
Method: result-summary ((r check-result) &optional code total passed erred failed warned other)
Generic Function: run-command-actual (command &rest args)

Top-level command interpreter for the NST tester

Package

nst.

Source

command.lisp.

Methods
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::apply)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::whatis)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::unset)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::set)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::clear)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::detail)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::report)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::run)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::run-test)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::run-group)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::run-package)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::open)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::debug)) &rest g0)
Method: run-command-actual ((cmd (eql nst-artifact-lookup-package::help)) &rest g0)
Method: run-command-actual (command &rest args)
Method: run-command-actual :before (command &rest args)
Generic Function: set-nst-property (name value)
Package

nst.

Source

globals.lisp.

Methods
Method: set-nst-property ((name (eql :verbose)) value)
Source

command.lisp.

Method: set-nst-property ((name (eql :debug-on-fail)) value)
Source

command.lisp.

Method: set-nst-property ((name (eql :debug-on-error)) value)
Source

command.lisp.

Method: set-nst-property (name value)
Generic Function: show-context-layer (layer)

Used to determine whether a context-layer should be displayed. Methods may safely refer and mutate the hashtable stored in the special variable -context-display-state- .

Package

nst.

Source

context.lisp.

Methods
Method: show-context-layer ((layer method-context-layer))
Source

method.lisp.

Method: show-context-layer ((layer criterion-context-layer))
Method: show-context-layer (l)
Generic Function: show-nst-property (name)

Display a property value (presumably) to the REPL.

Package

nst.

Source

globals.lisp.

Methods
Method: show-nst-property ((name (eql :verbose)))
Source

command.lisp.

Method: show-nst-property ((name (eql :debug-on-fail)))
Source

command.lisp.

Method: show-nst-property ((name (eql :debug-on-error)))
Source

command.lisp.

Generic Reader: test (condition)
Package

nst.

Methods
Reader Method: test ((condition no-such-nst-test))
Source

errors.lisp.

Target Slot

test.

Generic Function: trace-group (gr)

Provide debugging information about a group.

Package

nst.

Source

artifacts.lisp.

Methods
Method: trace-group ((g group-record))
Source

group.lisp.

Method: trace-group (gr)
Generic Function: trace-test (gr ts)

Provide debugging information about a test.

Package

nst.

Source

artifacts.lisp.

Methods
Method: trace-test ((gr group-record) (ts test-record))

Return non-nil if an item is a group record.

Source

test-def.lisp.

Method: trace-test (gr ts)

6.2.6 Conditions

Condition: criterion-missing-mandatory-argument
Package

nst.

Source

errors.lisp.

Direct superclasses

nst-error.

Direct methods
Direct slots
Slot: criterion-name
Initargs

:criterion-name

Readers

criterion-name.

Writers

This slot is read-only.

Slot: required-keyarg
Initargs

:required-keyarg

Readers

required-keyarg.

Writers

This slot is read-only.

Condition: debug-for-fail

Condition raised

Package

nst.

Source

errors.lisp.

Direct superclasses

condition.

Condition: no-nst-groups-in-package
Package

nst.

Source

errors.lisp.

Direct superclasses

nst-error.

Direct methods

package-of.

Direct slots
Slot: package
Package

common-lisp.

Initargs

:package

Readers

package-of.

Writers

This slot is read-only.

Condition: no-such-nst-group
Package

nst.

Source

errors.lisp.

Direct superclasses

nst-error.

Direct methods

group.

Direct slots
Slot: group
Initargs

:group

Readers

group.

Writers

This slot is read-only.

Condition: no-such-nst-test
Package

nst.

Source

errors.lisp.

Direct superclasses

nst-error.

Direct methods
Direct slots
Slot: group
Initargs

:group

Readers

group.

Writers

This slot is read-only.

Slot: test
Initargs

:test

Readers

test.

Writers

This slot is read-only.

Condition: not-expected-form
Package

nst.

Source

errors.lisp.

Direct superclasses

nst-error.

Direct methods
Direct slots
Slot: expected-form
Initargs

:expected-form

Readers

expected-form.

Writers

This slot is read-only.

Slot: actual-value
Initargs

:actual-value

Readers

actual-value.

Writers

This slot is read-only.

Condition: nst-assertion-condition
Package

nst.

Source

process.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods

assertion-failure-fatal.

Direct slots
Slot: fatal
Initargs

:fatal

Readers

assertion-failure-fatal.

Writers

This slot is read-only.

Condition: nst-assertion-failure
Package

nst.

Source

process.lisp.

Direct superclasses

nst-assertion-condition.

Direct methods
Direct slots
Slot: formatter
Package

common-lisp.

Initargs

:formatter

Readers

assertion-failure-formatter.

Writers

This slot is read-only.

Slot: args
Initargs

:args

Readers

assertion-failure-args.

Writers

This slot is read-only.

Condition: nst-assertion-result-check
Package

nst.

Source

process.lisp.

Direct superclasses

nst-assertion-condition.

Direct methods

nst-assertion-result.

Direct slots
Slot: result
Initargs

:result

Readers

nst-assertion-result.

Writers

This slot is read-only.

Condition: nst-deprecation-warning-mixin

Mixin of field used in deprecation warnings

Package

nst.

Source

errors.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods
Direct slots
Slot: old-name
Initargs

:old-name

Readers

old-name.

Writers

This slot is read-only.

Slot: replacement
Initargs

:replacement

Readers

replacement.

Writers

This slot is read-only.

Condition: nst-error
Package

nst.

Source

errors.lisp.

Direct superclasses

condition.

Direct subclasses
Condition: nst-hard-deprecation
Package

nst.

Source

errors.lisp.

Direct superclasses
Condition: nst-soft-deprecation
Package

nst.

Source

errors.lisp.

Direct superclasses
Condition: nst-soft-keyarg-deprecation
Package

nst.

Source

errors.lisp.

Direct superclasses
Condition: unknown-arbitrary-domain
Package

nst.

Source

sampling.lisp.

Direct superclasses

nst-error.

Direct methods
Direct slots
Slot: domain
Initargs

:domain

Readers

domain.

Writers

This slot is read-only.

Slot: keyword-args
Initargs

:keyword-args

Readers

keyword-args.

Writers

This slot is read-only.


6.2.7 Structures

Structure: check-note

A single note issued in criteria checking.
context - the surrounding criteria structure, a list of context-layer structs stack - the stack of values at the note point
format, args - further details; this string and list may e.g. be provided to cl:format

** IMPORTANT ** Do not use check-note-format or check-note-args! Do not assume that the format slot is a string! The API for these slots is apply-check-note-formatter, which checks for function values (or other types allowed as a formatter since the time when this docstring was written).

Package

nst.

Source

status.lisp.

Direct superclasses

structure-object.

Direct subclasses

error-check-note.

Direct methods

add-warning.

Direct slots
Slot: context
Readers

check-note-context.

Writers

(setf check-note-context).

Slot: stack
Readers

check-note-stack.

Writers

(setf check-note-stack).

Slot: format
Package

common-lisp.

Readers

check-note-format.

Writers

(setf check-note-format).

Slot: args
Readers

check-note-args.

Writers

(setf check-note-args).

Structure: check-result

Overall check result structure, containing notes of four distinct types. A note is an instance of the check-note structure below. The four note types are: warnings - generated warnings
failures - criteria which are not met, but not a Lisp error
errors - Lisp errors
skipped - skipped information if the test is skipped.
info - supplimentary information
Each of these fields is a list; warnings, failures and errors are check-note instances, and the info field is of any value.

Package

nst.

Source

status.lisp.

Direct superclasses

result-stats.

Direct methods

result-summary.

Direct slots
Slot: tests
Initform

1

Readers

check-result-tests.

Writers

(setf check-result-tests).

Slot: group-name
Initform

nst::*nst-group-name*

Readers

check-result-group-name.

Writers

(setf check-result-group-name).

Slot: check-name
Initform

nst::*nst-check-user-name*

Readers

check-result-check-name.

Writers

(setf check-result-check-name).

Slot: warnings
Readers

check-result-warnings.

Writers

(setf check-result-warnings).

Slot: failures
Readers

check-result-failures.

Writers

(setf check-result-failures).

Slot: errors
Readers

check-result-errors.

Writers

(setf check-result-errors).

Slot: skipped
Readers

check-result-skipped.

Writers

(setf check-result-skipped).

Slot: info
Readers

check-result-info.

Writers

(setf check-result-info).

Structure: error-check-note

A note issued in regards to a thrown error.

Package

nst.

Source

status.lisp.

Direct superclasses

check-note.

Direct slots
Slot: error
Package

common-lisp.

Readers

error-check-note-error.

Writers

(setf error-check-note-error).

Structure: fixture-record

Information associated with a fixture definition

Package

nst.

Source

fixture.lisp.

Direct superclasses

structure-object.

Direct methods

base-name.

Direct slots
Slot: name
Readers

fixture-record-name.

Writers

(setf fixture-record-name).

Slot: function
Package

common-lisp.

Readers

fixture-record-function.

Writers

(setf fixture-record-function).

Slot: bound-names
Readers

fixture-record-bound-names.

Writers

(setf fixture-record-bound-names).

Slot: bindings-list
Readers

fixture-record-bindings-list.

Writers

(setf fixture-record-bindings-list).

Slot: documentation
Package

common-lisp.

Readers

fixture-record-documentation.

Writers

(setf fixture-record-documentation).

Slot: cache-flush
Readers

fixture-record-cache-flush.

Writers

(setf fixture-record-cache-flush).

Structure: group-record

Superclass of NST group definitions.

Package

nst.

Source

group.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: name
Readers

group-record-name.

Writers

(setf group-record-name).

Slot: anon-fixture-forms
Readers

group-record-anon-fixture-forms.

Writers

(setf group-record-anon-fixture-forms).

Slot: aspirational
Readers

group-record-aspirational.

Writers

(setf group-record-aspirational).

Slot: given-fixtures
Readers

group-record-given-fixtures.

Writers

(setf group-record-given-fixtures).

Slot: documentation
Package

common-lisp.

Readers

group-record-documentation.

Writers

(setf group-record-documentation).

Slot: tests
Initform

(make-hash-table :test (quote eq))

Readers

group-record-tests.

Writers

(setf group-record-tests).

Slot: fixtures-setup-thunk
Readers

group-record-fixtures-setup-thunk.

Writers

(setf group-record-fixtures-setup-thunk).

Slot: fixtures-cleanup-thunk
Readers

group-record-fixtures-cleanup-thunk.

Writers

(setf group-record-fixtures-cleanup-thunk).

Slot: withfixtures-setup-thunk
Readers

group-record-withfixtures-setup-thunk.

Writers

(setf group-record-withfixtures-setup-thunk).

Slot: withfixtures-cleanup-thunk
Readers

group-record-withfixtures-cleanup-thunk.

Writers

(setf group-record-withfixtures-cleanup-thunk).

Slot: eachtest-setup-thunk
Readers

group-record-eachtest-setup-thunk.

Writers

(setf group-record-eachtest-setup-thunk).

Slot: eachtest-cleanup-thunk
Readers

group-record-eachtest-cleanup-thunk.

Writers

(setf group-record-eachtest-cleanup-thunk).

Slot: include-groups
Readers

group-record-include-groups.

Writers

(setf group-record-include-groups).

Structure: group-result

Overall group result structure, mapping checks to results by name.

Package

nst.

Source

status.lisp.

Direct superclasses

result-stats.

Direct methods
Direct slots
Slot: group-name
Readers

group-result-group-name.

Writers

(setf group-result-group-name).

Slot: check-results
Initform

(make-hash-table :test (quote eq))

Readers

group-result-check-results.

Writers

(setf group-result-check-results).

Structure: multi-results

Multiple results structure.

Package

nst.

Source

status.lisp.

Direct superclasses

result-stats.

Direct methods

result-summary.

Direct slots
Slot: package-reports
Readers

multi-results-package-reports.

Writers

(setf multi-results-package-reports).

Slot: group-reports
Readers

multi-results-group-reports.

Writers

(setf multi-results-group-reports).

Slot: test-reports
Readers

multi-results-test-reports.

Writers

(setf multi-results-test-reports).

Slot: system
Readers

multi-results-system.

Writers

(setf multi-results-system).

Slot: stats-source
Readers

multi-results-stats-source.

Writers

(setf multi-results-stats-source).

Structure: name-use

Record for tracking the artifacts which NST associates with a name.

Package

nst.

Source

artifacts.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Readers

name-use-name.

Writers

(setf name-use-name).

Slot: fixtures
Readers

name-use-fixtures.

Writers

(setf name-use-fixtures).

Slot: groups
Readers

name-use-groups.

Writers

(setf name-use-groups).

Slot: tests
Readers

name-use-tests.

Writers

(setf name-use-tests).

Slot: package-p
Readers

name-use-package-p.

Writers

(setf name-use-package-p).

Slot: last-use
Readers

name-use-last-use.

Writers

(setf name-use-last-use).

Structure: package-result

Overall package result structure, mapping groups to results by name.

Package

nst.

Source

status.lisp.

Direct superclasses

result-stats.

Direct methods

result-summary.

Direct slots
Slot: package-name
Package

common-lisp.

Readers

package-result-package-name.

Writers

(setf package-result-package-name).

Slot: group-results
Initform

(make-hash-table :test (quote eq))

Readers

package-result-group-results.

Writers

(setf package-result-group-results).

Structure: result-stats

Statistics common to the different result summaries.

Package

nst.

Source

artifacts.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct slots
Slot: tests
Initform

0

Readers

result-stats-tests.

Writers

(setf result-stats-tests).

Slot: passing
Initform

0

Readers

result-stats-passing.

Writers

(setf result-stats-passing).

Slot: erring
Initform

0

Readers

result-stats-erring.

Writers

(setf result-stats-erring).

Slot: failing
Initform

0

Readers

result-stats-failing.

Writers

(setf result-stats-failing).

Slot: warning
Package

common-lisp.

Initform

0

Readers

result-stats-warning.

Writers

(setf result-stats-warning).

Slot: elapsed-time
Initform

0

Readers

result-stats-elapsed-time.

Writers

(setf result-stats-elapsed-time).

Slot: timestamp
Initform

(multiple-value-list (get-decoded-time))

Readers

result-stats-timestamp.

Writers

(setf result-stats-timestamp).

Structure: test-record

Structure storing parsed NST test records.
- =group= :: The group-record structure (not the symbolic name) of the group containing this test.

Package

nst.

Source

test-def.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: name
Readers

test-record-name.

Writers

(setf test-record-name).

Slot: group
Readers

test-record-group.

Writers

(setf test-record-group).

Slot: fixtures
Readers

test-record-fixtures.

Writers

(setf test-record-fixtures).

Slot: criterion
Readers

test-record-criterion.

Writers

(setf test-record-criterion).

Slot: forms
Readers

test-record-forms.

Writers

(setf test-record-forms).

Slot: special-fixture-names
Readers

test-record-special-fixture-names.

Writers

(setf test-record-special-fixture-names).

Slot: documentation
Package

common-lisp.

Readers

test-record-documentation.

Writers

(setf test-record-documentation).

Slot: setup
Readers

test-record-setup.

Writers

(setf test-record-setup).

Slot: cleanup
Readers

test-record-cleanup.

Writers

(setf test-record-cleanup).

Slot: startup
Readers

test-record-startup.

Writers

(setf test-record-startup).

Slot: finish
Readers

test-record-finish.

Writers

(setf test-record-finish).

Slot: results
Readers

test-record-results.

Writers

(setf test-record-results).

Slot: aspirational
Readers

test-record-aspirational.

Writers

(setf test-record-aspirational).

Slot: aspirational-supp
Readers

test-record-aspirational-supp.

Writers

(setf test-record-aspirational-supp).


6.2.8 Classes

Class: context-layer

Superclass of records of test criterion.

Package

nst.

Source

context.lisp.

Direct subclasses
Class: criterion-context-layer

A record of test criterion
criterion - the criterion symbol itself
criterion-args - arguments to the criterion
given-stack - the stack of values assessed by the criterion

Package

nst.

Source

context.lisp.

Direct superclasses

context-layer.

Direct methods
Direct slots
Slot: criterion
Initargs

:criterion

Readers

criterion.

Writers

(setf criterion).

Slot: criterion-args
Initargs

:criterion-args

Readers

criterion-args.

Writers

(setf criterion-args).

Slot: given-stack
Initargs

:given-stack

Readers

given-stack.

Writers

(setf given-stack).

Class: method-context-layer

A record of method-based test invocation.

Package

nst.

Source

method.lisp.

Direct superclasses

context-layer.

Direct methods
Direct slots
Slot: method-name
Initargs

:method-name

Readers

method-name.

Writers

(setf method-name).

Slot: class-name
Package

common-lisp.

Initargs

:class-name

Readers

class-name.

Writers

(setf class-name).

Slot: object
Initargs

:object

Readers

object.

Writers

(setf object).

Class: permuter
Package

nst.

Source

permuter.lisp.

Direct methods
Direct slots
Slot: next-permutation
Type

(or null cons)

Slot: perm-stack
Type

(or null (cons nst::permuter-frame))

Slot: has-next
Initform

t

Readers

has-next.

Writers

This slot is read-only.

Slot: degenerate
Class: permuter-frame
Package

nst.

Source

permuter.lisp.

Direct methods

fmt-permuter.

Direct slots
Slot: next-firsts
Type

(or null cons)

Initargs

:next

Slot: prev-firsts
Type

(or null cons)


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

%
%make-check-result: Private ordinary functions

(
(setf check-note-args): Private ordinary functions
(setf check-note-context): Private ordinary functions
(setf check-note-format): Private ordinary functions
(setf check-note-stack): Private ordinary functions
(setf check-result-check-name): Private ordinary functions
(setf check-result-elapsed-time): Private ordinary functions
(setf check-result-erring): Private ordinary functions
(setf check-result-errors): Private ordinary functions
(setf check-result-failing): Private ordinary functions
(setf check-result-failures): Private ordinary functions
(setf check-result-group-name): Private ordinary functions
(setf check-result-info): Private ordinary functions
(setf check-result-passing): Private ordinary functions
(setf check-result-skipped): Private ordinary functions
(setf check-result-tests): Private ordinary functions
(setf check-result-timestamp): Private ordinary functions
(setf check-result-warning): Private ordinary functions
(setf check-result-warnings): Private ordinary functions
(setf class-name): Public standalone methods
(setf criterion): Private generic functions
(setf criterion): Private generic functions
(setf criterion-args): Private generic functions
(setf criterion-args): Private generic functions
(setf error-check-note-args): Private ordinary functions
(setf error-check-note-context): Private ordinary functions
(setf error-check-note-error): Private ordinary functions
(setf error-check-note-format): Private ordinary functions
(setf error-check-note-stack): Private ordinary functions
(setf fixture-bindings): Private ordinary functions
(setf fixture-letlist): Private ordinary functions
(setf fixture-record): Private ordinary functions
(setf fixture-record-bindings-list): Private ordinary functions
(setf fixture-record-bound-names): Private ordinary functions
(setf fixture-record-cache-flush): Private ordinary functions
(setf fixture-record-documentation): Private ordinary functions
(setf fixture-record-function): Private ordinary functions
(setf fixture-record-name): Private ordinary functions
(setf given-stack): Private generic functions
(setf given-stack): Private generic functions
(setf group-record): Private ordinary functions
(setf group-record-anon-fixture-forms): Private ordinary functions
(setf group-record-aspirational): Private ordinary functions
(setf group-record-documentation): Private ordinary functions
(setf group-record-eachtest-cleanup-thunk): Private ordinary functions
(setf group-record-eachtest-setup-thunk): Private ordinary functions
(setf group-record-fixtures-cleanup-thunk): Private ordinary functions
(setf group-record-fixtures-setup-thunk): Private ordinary functions
(setf group-record-given-fixtures): Private ordinary functions
(setf group-record-include-groups): Private ordinary functions
(setf group-record-name): Private ordinary functions
(setf group-record-tests): Private ordinary functions
(setf group-record-withfixtures-cleanup-thunk): Private ordinary functions
(setf group-record-withfixtures-setup-thunk): Private ordinary functions
(setf group-result-check-results): Private ordinary functions
(setf group-result-elapsed-time): Private ordinary functions
(setf group-result-erring): Private ordinary functions
(setf group-result-failing): Private ordinary functions
(setf group-result-group-name): Private ordinary functions
(setf group-result-passing): Private ordinary functions
(setf group-result-tests): Private ordinary functions
(setf group-result-timestamp): Private ordinary functions
(setf group-result-warning): Private ordinary functions
(setf method-name): Private generic functions
(setf method-name): Private generic functions
(setf multi-results-elapsed-time): Private ordinary functions
(setf multi-results-erring): Private ordinary functions
(setf multi-results-failing): Private ordinary functions
(setf multi-results-group-reports): Private ordinary functions
(setf multi-results-package-reports): Private ordinary functions
(setf multi-results-passing): Private ordinary functions
(setf multi-results-stats-source): Private ordinary functions
(setf multi-results-system): Private ordinary functions
(setf multi-results-test-reports): Private ordinary functions
(setf multi-results-tests): Private ordinary functions
(setf multi-results-timestamp): Private ordinary functions
(setf multi-results-warning): Private ordinary functions
(setf name-use-fixtures): Private ordinary functions
(setf name-use-groups): Private ordinary functions
(setf name-use-last-use): Private ordinary functions
(setf name-use-name): Private ordinary functions
(setf name-use-package-p): Private ordinary functions
(setf name-use-tests): Private ordinary functions
(setf object): Private generic functions
(setf object): Private generic functions
(setf package-result-elapsed-time): Private ordinary functions
(setf package-result-erring): Private ordinary functions
(setf package-result-failing): Private ordinary functions
(setf package-result-group-results): Private ordinary functions
(setf package-result-package-name): Private ordinary functions
(setf package-result-passing): Private ordinary functions
(setf package-result-tests): Private ordinary functions
(setf package-result-timestamp): Private ordinary functions
(setf package-result-warning): Private ordinary functions
(setf result-stats-elapsed-time): Private ordinary functions
(setf result-stats-erring): Private ordinary functions
(setf result-stats-failing): Private ordinary functions
(setf result-stats-passing): Private ordinary functions
(setf result-stats-tests): Private ordinary functions
(setf result-stats-timestamp): Private ordinary functions
(setf result-stats-warning): Private ordinary functions
(setf test-record): Private ordinary functions
(setf test-record-aspirational): Private ordinary functions
(setf test-record-aspirational-supp): Private ordinary functions
(setf test-record-cleanup): Private ordinary functions
(setf test-record-criterion): Private ordinary functions
(setf test-record-documentation): Private ordinary functions
(setf test-record-finish): Private ordinary functions
(setf test-record-fixtures): Private ordinary functions
(setf test-record-forms): Private ordinary functions
(setf test-record-group): Private ordinary functions
(setf test-record-name): Private ordinary functions
(setf test-record-results): Private ordinary functions
(setf test-record-setup): Private ordinary functions
(setf test-record-special-fixture-names): Private ordinary functions
(setf test-record-startup): Private ordinary functions

A
actual-value: Private generic functions
actual-value: Private generic functions
add-error: Public ordinary functions
add-failure: Public ordinary functions
add-info: Public ordinary functions
add-thrown-error: Private ordinary functions
add-warning: Public generic functions
add-warning: Public generic functions
add-warning: Public generic functions
add-warning: Public generic functions
all-groups-report: Private ordinary functions
all-package-report: Private ordinary functions
all-tests-report: Private ordinary functions
all-uses: Private ordinary functions
apply-check-note-formatter: Private ordinary functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-criterion: Private generic functions
apply-debug-options: Private macros
apply-default-debug-options: Private macros
apply-fixture: Private ordinary functions
apply-fixtures: Private ordinary functions
apply-formatter: Private ordinary functions
arbitrary: Public generic functions
arbitrary: Public generic functions
arbitrary: Public generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-by-spec: Private generic functions
arbitrary-generable-types: Private ordinary functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
arbitrary-grounded-type: Private generic functions
artifact-recorder: Private ordinary functions
assemble-protected-option-values: Private ordinary functions
assert-criterion: Public macros
assert-criterion-fn: Private ordinary functions
assert-eq: Public ordinary functions
assert-eql: Public ordinary functions
assert-equal: Public ordinary functions
assert-equalp: Public ordinary functions
assert-non-nil: Public ordinary functions
assert-not-eq: Public ordinary functions
assert-not-eql: Public ordinary functions
assert-not-equal: Public ordinary functions
assert-not-equalp: Public ordinary functions
assert-null: Public ordinary functions
assert-zero: Public ordinary functions
assertion-failure-args: Private generic functions
assertion-failure-args: Private generic functions
assertion-failure-fatal: Private generic functions
assertion-failure-fatal: Private generic functions
assertion-failure-formatter: Private generic functions
assertion-failure-formatter: Private generic functions
at-verbosity: Private macros

B
base-name: Private generic functions
base-name: Private generic functions
base-name: Private generic functions
base-name: Private generic functions
base-name: Private generic functions
base-name: Private generic functions
blurb-one-name-use: Private ordinary functions
build-continue-check-expr: Private ordinary functions

C
calibrate-check-result: Private ordinary functions
cdr-or-nil: Private ordinary functions
check-criterion-on-form: Public ordinary functions
check-criterion-on-value: Public ordinary functions
check-note-args: Private ordinary functions
check-note-context: Private ordinary functions
check-note-format: Private ordinary functions
check-note-p: Private ordinary functions
check-note-stack: Private ordinary functions
check-note-type-string: Private generic functions
check-note-type-string: Private generic functions
check-note-type-string: Private generic functions
check-result: Private macros
check-result-check-name: Private ordinary functions
check-result-elapsed-time: Private ordinary functions
check-result-erring: Private ordinary functions
check-result-errors: Private ordinary functions
check-result-failing: Private ordinary functions
check-result-failures: Private ordinary functions
check-result-group-name: Private ordinary functions
check-result-info: Private ordinary functions
check-result-p: Private ordinary functions
check-result-passing: Private ordinary functions
check-result-skipped: Private ordinary functions
check-result-tests: Private ordinary functions
check-result-timestamp: Private ordinary functions
check-result-union: Private ordinary functions
check-result-warning: Private ordinary functions
check-result-warnings: Private ordinary functions
class-name: Public standalone methods
coin-flip: Private macros
collect-test-generics: Private ordinary functions
compound-structure: Public macros
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
consider-repl-call-save: Private generic functions
continue-check: Private ordinary functions
copy-check-note: Private ordinary functions
copy-check-result: Private ordinary functions
copy-error-check-note: Private ordinary functions
copy-fixture-record: Private ordinary functions
copy-group-record: Private ordinary functions
copy-group-result: Private ordinary functions
copy-multi-results: Private ordinary functions
copy-name-use: Private ordinary functions
copy-package-result: Private ordinary functions
copy-result-stats: Private ordinary functions
copy-test-record: Private ordinary functions
core-run-test: Private ordinary functions
count-nonnulls: Private macros
criterion: Private generic functions
criterion: Private generic functions
criterion-args: Private generic functions
criterion-args: Private generic functions
criterion-name: Private generic functions
criterion-name: Private generic functions

D
decode-caching-decls: Private ordinary functions
decode-def-test-generic-body: Private ordinary functions
decode-defcheck-name-and-args: Private ordinary functions
decode-fixture-syntax: Private ordinary functions
decompose-arg-values-lambda-list: Private ordinary functions
def-arbitrary-instance-type: Public macros
def-binary-negated-predicate-assert: Public macros
def-binary-predicate-assert: Public macros
def-bundle-package: Private macros
def-check: Private macros
def-check-alias: Private macros
def-control-check: Private macros
def-criterion: Public macros
def-criterion-alias: Public macros
def-criterion-unevaluated: Public macros
def-eval-test: Public macros
def-fixtures: Public macros
def-form-criterion: Public macros
def-hashtable-fns: Private macros
def-nst-interactive-command: Private macros
def-nst-property: Private macros
def-test: Public macros
def-test-generic: Public macros
def-test-group: Public macros
def-test-method: Public macros
def-test-method-criterion: Public macros
def-unary-negated-predicate-assert: Public macros
def-unary-predicate-assert: Public macros
def-value-check: Private macros
def-values-criterion: Public macros
define-nst-error: Private macros
domain: Private generic functions
domain: Private generic functions

E
elapsed-time-to-string: Private ordinary functions
emit-error: Private macros
emit-failure: Public macros
emit-success: Public macros
emit-warning: Public macros
eql-for-sigdigits: Private ordinary functions
error-check-note-args: Private ordinary functions
error-check-note-context: Private ordinary functions
error-check-note-error: Private ordinary functions
error-check-note-format: Private ordinary functions
error-check-note-p: Private ordinary functions
error-check-note-stack: Private ordinary functions
executable-uses: Private ordinary functions
expected-form: Private generic functions
expected-form: Private generic functions
extract-parameters: Private ordinary functions

F
finish-multiple-report: Private ordinary functions
fixture-binding-error-note: Private ordinary functions
fixture-bindings: Private ordinary functions
fixture-letlist: Private ordinary functions
fixture-record: Private ordinary functions
fixture-record-bindings-list: Private ordinary functions
fixture-record-bound-names: Private ordinary functions
fixture-record-cache-flush: Private ordinary functions
fixture-record-documentation: Private ordinary functions
fixture-record-function: Private ordinary functions
fixture-record-name: Private ordinary functions
fixture-record-p: Private ordinary functions
flag-filter: Private ordinary functions
flush-fixture-cache: Private ordinary functions
fmt-permuter: Private generic functions
fmt-permuter: Private generic functions
fmt-permuter: Private generic functions
format-at-verbosity: Private macros
format-for-warning: Private generic functions
format-for-warning: Private generic functions
Function, %make-check-result: Private ordinary functions
Function, (setf check-note-args): Private ordinary functions
Function, (setf check-note-context): Private ordinary functions
Function, (setf check-note-format): Private ordinary functions
Function, (setf check-note-stack): Private ordinary functions
Function, (setf check-result-check-name): Private ordinary functions
Function, (setf check-result-elapsed-time): Private ordinary functions
Function, (setf check-result-erring): Private ordinary functions
Function, (setf check-result-errors): Private ordinary functions
Function, (setf check-result-failing): Private ordinary functions
Function, (setf check-result-failures): Private ordinary functions
Function, (setf check-result-group-name): Private ordinary functions
Function, (setf check-result-info): Private ordinary functions
Function, (setf check-result-passing): Private ordinary functions
Function, (setf check-result-skipped): Private ordinary functions
Function, (setf check-result-tests): Private ordinary functions
Function, (setf check-result-timestamp): Private ordinary functions
Function, (setf check-result-warning): Private ordinary functions
Function, (setf check-result-warnings): Private ordinary functions
Function, (setf error-check-note-args): Private ordinary functions
Function, (setf error-check-note-context): Private ordinary functions
Function, (setf error-check-note-error): Private ordinary functions
Function, (setf error-check-note-format): Private ordinary functions
Function, (setf error-check-note-stack): Private ordinary functions
Function, (setf fixture-bindings): Private ordinary functions
Function, (setf fixture-letlist): Private ordinary functions
Function, (setf fixture-record): Private ordinary functions
Function, (setf fixture-record-bindings-list): Private ordinary functions
Function, (setf fixture-record-bound-names): Private ordinary functions
Function, (setf fixture-record-cache-flush): Private ordinary functions
Function, (setf fixture-record-documentation): Private ordinary functions
Function, (setf fixture-record-function): Private ordinary functions
Function, (setf fixture-record-name): Private ordinary functions
Function, (setf group-record): Private ordinary functions
Function, (setf group-record-anon-fixture-forms): Private ordinary functions
Function, (setf group-record-aspirational): Private ordinary functions
Function, (setf group-record-documentation): Private ordinary functions
Function, (setf group-record-eachtest-cleanup-thunk): Private ordinary functions
Function, (setf group-record-eachtest-setup-thunk): Private ordinary functions
Function, (setf group-record-fixtures-cleanup-thunk): Private ordinary functions
Function, (setf group-record-fixtures-setup-thunk): Private ordinary functions
Function, (setf group-record-given-fixtures): Private ordinary functions
Function, (setf group-record-include-groups): Private ordinary functions
Function, (setf group-record-name): Private ordinary functions
Function, (setf group-record-tests): Private ordinary functions
Function, (setf group-record-withfixtures-cleanup-thunk): Private ordinary functions
Function, (setf group-record-withfixtures-setup-thunk): Private ordinary functions
Function, (setf group-result-check-results): Private ordinary functions
Function, (setf group-result-elapsed-time): Private ordinary functions
Function, (setf group-result-erring): Private ordinary functions
Function, (setf group-result-failing): Private ordinary functions
Function, (setf group-result-group-name): Private ordinary functions
Function, (setf group-result-passing): Private ordinary functions
Function, (setf group-result-tests): Private ordinary functions
Function, (setf group-result-timestamp): Private ordinary functions
Function, (setf group-result-warning): Private ordinary functions
Function, (setf multi-results-elapsed-time): Private ordinary functions
Function, (setf multi-results-erring): Private ordinary functions
Function, (setf multi-results-failing): Private ordinary functions
Function, (setf multi-results-group-reports): Private ordinary functions
Function, (setf multi-results-package-reports): Private ordinary functions
Function, (setf multi-results-passing): Private ordinary functions
Function, (setf multi-results-stats-source): Private ordinary functions
Function, (setf multi-results-system): Private ordinary functions
Function, (setf multi-results-test-reports): Private ordinary functions
Function, (setf multi-results-tests): Private ordinary functions
Function, (setf multi-results-timestamp): Private ordinary functions
Function, (setf multi-results-warning): Private ordinary functions
Function, (setf name-use-fixtures): Private ordinary functions
Function, (setf name-use-groups): Private ordinary functions
Function, (setf name-use-last-use): Private ordinary functions
Function, (setf name-use-name): Private ordinary functions
Function, (setf name-use-package-p): Private ordinary functions
Function, (setf name-use-tests): Private ordinary functions
Function, (setf package-result-elapsed-time): Private ordinary functions
Function, (setf package-result-erring): Private ordinary functions
Function, (setf package-result-failing): Private ordinary functions
Function, (setf package-result-group-results): Private ordinary functions
Function, (setf package-result-package-name): Private ordinary functions
Function, (setf package-result-passing): Private ordinary functions
Function, (setf package-result-tests): Private ordinary functions
Function, (setf package-result-timestamp): Private ordinary functions
Function, (setf package-result-warning): Private ordinary functions
Function, (setf result-stats-elapsed-time): Private ordinary functions
Function, (setf result-stats-erring): Private ordinary functions
Function, (setf result-stats-failing): Private ordinary functions
Function, (setf result-stats-passing): Private ordinary functions
Function, (setf result-stats-tests): Private ordinary functions
Function, (setf result-stats-timestamp): Private ordinary functions
Function, (setf result-stats-warning): Private ordinary functions
Function, (setf test-record): Private ordinary functions
Function, (setf test-record-aspirational): Private ordinary functions
Function, (setf test-record-aspirational-supp): Private ordinary functions
Function, (setf test-record-cleanup): Private ordinary functions
Function, (setf test-record-criterion): Private ordinary functions
Function, (setf test-record-documentation): Private ordinary functions