The parachute Reference Manual

This is the parachute Reference Manual, version 1.5.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 06:27:45 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 parachute

An extensible and cross-compatible testing framework.

Maintainer

Yukari Hafner <>

Author

Yukari Hafner <>

Home Page

https://Shinmera.github.io/parachute/

Source Control

(GIT https://github.com/Shinmera/parachute.git)

Bug Tracker

https://github.com/Shinmera/parachute/issues

License

zlib

Version

1.5.0

Dependencies
  • documentation-utils (system).
  • trivial-custom-debugger (system).
  • form-fiddle (system).
Source

parachute.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 parachute/parachute.asd

Source

parachute.asd.

Parent Component

parachute (system).

ASDF Systems

parachute.


3.1.2 parachute/package.lisp

Source

parachute.asd.

Parent Component

parachute (system).

Packages

parachute.


3.1.3 parachute/toolkit.lisp

Dependency

package.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface
Internals

3.1.4 parachute/fixture.lisp

Dependency

toolkit.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface

3.1.5 parachute/test.lisp

Dependency

fixture.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface
Internals

3.1.6 parachute/result.lisp

Dependency

test.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface
Internals

3.1.7 parachute/tester.lisp

Dependency

result.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface
Internals

destructure-is-values-body (function).


3.1.8 parachute/report.lisp

Dependency

tester.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).

Public Interface
Internals

3.1.9 parachute/documentation.lisp

Dependency

report.lisp (file).

Source

parachute.asd.

Parent Component

parachute (system).


4 Packages

Packages are listed by definition order.


4.1 parachute

Source

package.lisp.

Nickname

org.shirakumo.parachute

Use List

common-lisp.

Public Interface
Internals

5 Definitions

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


5.1 Public Interface


5.1.1 Special variables

Special Variable: *abort-on-timeout-p*

Whether the implementation should try to abort tests that exceed their time-limit.

This defaults to NIL and will only abort on supported
implementations. Note that using this switch will basically cause
unwinds to happen whenever the time limit exceeds, which can cause all
sorts of problems, as it is unpredictable exactly where in the code it
occurs.

See TIME-LIMIT

Package

parachute.

Source

test.lisp.

Special Variable: *context*

Variable storing the current context of the evaluation.

While EVAL-IN-CONTEXT already carries the context as an argument, in certain situations like when opaque functions are evaluated, testers within the execution context must be able to access the context object in order to evaluate properly.

Package

parachute.

Source

result.lisp.

Special Variable: *fixture-captures*

A map of names to fixture capture functions.

See DEFINE-FIXTURE-CAPTURE

Package

parachute.

Source

fixture.lisp.

Special Variable: *fixture-restores*

A map of names to fixture restore functions.

See DEFINE-FIXTURE-RESTORE

Package

parachute.

Source

fixture.lisp.

Special Variable: *parent*

Variable storing the immediate parent in the current evaluation context.

This is used in order to register a result within its parent.

Package

parachute.

Source

result.lisp.

Special Variable: *silence-plain-compilation-errors-p*

Whether PLAIN report should silence errors.

See DEFINE-TEST+RUN

Package

parachute.

Source

test.lisp.

Special Variable: *status-indicators*

A plist which maps status values to a strings used in reports. Should have the status values of :passed, :failed, :skipped, :tentative and :unknown.

Package

parachute.

Source

toolkit.lisp.


5.1.2 Macros

Macro: define-fixture-capture (name args &body body)

Defines a capture function to fix a symbol binding.

A capture function should take a symbol and return a value to capture for it, and T as the secondary value if anything should be captured at all for the kind of binding the function handles.

See *FIXTURE-CAPTURES*

Package

parachute.

Source

fixture.lisp.

Macro: define-fixture-restore (name args &body body)

Defines a restore function to fix a symbol binding.

A restoration function should take a symbol and a value and make sure to restore the binding it handles to the given value.

See *FIXTURE-RESTORES*

Package

parachute.

Source

fixture.lisp.

Macro: define-test (name &body arguments-and-body)

Defines a test.

NAME can be either a string, a symbol, or a list of a parent name and a name.

BODY ::= KARG* form*
KARG ::= keyword expression

Each karg in the body is used as an initialization argument to the test instance with the exception of :TEST-CLASS, which is used as the class-name to create a test instance with and defaults to TEST. The values of the keyword arguments are always passed quoted.

If you set a parent in the NAME, you cannot use the :PARENT karg and vice- versa. The following initargs are automatically always passed by DEFINE-TEST and should thus not appear as a karg: :NAME :TESTS :PARENT

You can define child tests within the body of the test if they appear as "toplevel" forms. They will be taken out of the body forms and emitted
as definition forms after the parent form, with the parent automatically set appropriately. As such, subtests defined in this manner cannot cause any effects on the surrounding environment.

Each form within the body will be turned into a separate test function. This is done so that the tests can be shuffled randomly if the test is not set as serial. This means that if you need to wrap multiple testers in any other form, the inner tests cannot be shuffled accordingly. However, you can use the WITH-SHUFFLING macro.

The karg :COMPILE-AT directs whether each test form should be compiled at definition time (default, value :COMPILE-TIME) or at test evaluation time (value :EXECUTE). The latter is achieved by, instead of a straight-up LAMBDA for each test form, it wraps it in a LAMBDA that calls COMPILE on the source form.

The karg :PARENT can be either a test designator, or a list of a package designator and a test name. The latter case allows you to set the test of another home package as the parent, useful if you split your tests across multiple packages.

Note that the dependencies of the test can be a combined by logic operators of :AND :OR and :NOT. See REFERENCED-DEPENDENCIES for the necessary structure.

If the test object to be defined already exists, the existing instance is updated as necessary instead of creating a new one. The update proceeds in two steps: If the requested :TEST-CLASS is different from the instance’s class the disparity is attempted to be reconciled through CHANGE-CLASS. The instance’s fields are then always updated via REINITIALIZE-INSTANCE. This should ensure that, in the normal case of redefining tests via DEFINE-TEST, test objects returned by FIND-TEST are EQ to each other under the same arguments.

See TEST
See FIND-TEST
See REMOVE-TEST
See REFERENCED-DEPENDENCIES

Package

parachute.

Source

test.lisp.

Macro: define-test+run (name &body args-and-body)

Pass NAME with ARGS-AND-BODY to DEFINE-TEST and, if the form is executed
(as opposed to being loaded or compiled), run the test and return a plain report. In case of failure, a list of all failed expressions is returned as the second value. Useful for interactivity: define and run the test at once and get the relevant information. Compilation errors are not muffled when running.

If you wrap this in your own macro and want to avoid test execution on project load/compilation, make sure to make the form toplevel and also use (eval-when :compile-toplevel :load-toplevel) to define the test, and (eval-when :execute) to run this macro.

See DEFINE-TEST+RUN-INTERACTIVELY
See PLAIN

Package

parachute.

Source

test.lisp.

Macro: define-test+run-interactively (name &body args-and-body)

Pass NAME with ARGS-AND-BODY to DEFINE-TEST and, if the form is executed (as opposed to being loaded or compiled), run the test with :REPORT set to INTERACTIVE.

See DEFINE-TEST+RUN
See INTERACTIVE

Package

parachute.

Source

test.lisp.

Macro: fail (form &optional type description &rest format-args)

A tester that succeeds if the form signals an error of the requested type, defaulting to ERROR.

Package

parachute.

Source

tester.lisp.

Macro: fail-compile (form &optional type description &rest format-args)

A tester that succeeds if the form fails to compile.

Note the form will not be executed, only compiled.

Package

parachute.

Source

tester.lisp.

Macro: false (form &optional description &rest format-args)

A tester that succeeds if the form returns NIL as the value.

Package

parachute.

Source

tester.lisp.

Macro: finish (form &optional description &rest format-args)

A tester that succeeds if the form returns without escaping.

Package

parachute.

Source

tester.lisp.

Macro: group ((name &optional description &rest format-args) &body tests)

Group the provided tests together under a name.

This is similar to defining a test, but allows the body to share the lexical context with the rest of the test forms.

Package

parachute.

Source

tester.lisp.

Macro: is (comp expected form &optional description &rest format-args)

A tester that succeeds if the value the form returns is equal to the expected value under the given comparator.

Package

parachute.

Source

tester.lisp.

Macro: is-values (form &body body)

A tester that succeeds if each value the form returns is equal to the corresponding expected value under the corresponding comparator.

The body consists of lists of two values, the first being the comparator,
the second being the expected value. A third, ignored value can be
supplied as well for aesthetic purposes.

Package

parachute.

Source

tester.lisp.

Macro: isnt (comp expected form &optional description &rest format-args)

A tester that succeeds if the value the form returns is not equal to the expected value under the given comparator.

Package

parachute.

Source

tester.lisp.

Macro: isnt-values (form &body body)

A tester that succeeds if each value the form returns is not equal to the corresponding expected value under the corresponding comparator.

The body consists of lists of two values, the first being the comparator,
the second being the expected value. A third, ignored value can be
supplied as well for aesthetic purposes.

Package

parachute.

Source

tester.lisp.

Macro: of-type (type form &optional description &rest format-args)

A tester that succeeds if the form returns a value that is of the requested type.

Package

parachute.

Source

tester.lisp.

Macro: skip (desc &body tests)

Skips the tests in the body by avoiding their evaluation and marking their status as :SKIPPED.

Package

parachute.

Source

tester.lisp.

Macro: skip-on (features desc &body tests)

Skips the tests in the body if any of the given feature expressions match.

If one of the feature expression matches, the evaluation of the tests in the body is skipped and the status of these tests is forced to :SKIPPED. Otherwise, the tests are evaluated as normal.

Note that if you have tests that will not /compile/ on a given feature combination, you still need to exclude those tests with reader conditionals as well.

See FEATUREP

Package

parachute.

Source

tester.lisp.

Macro: true (form &optional description &rest format-args)

A tester that succeeds if the form returns a non-NIL value.

Package

parachute.

Source

tester.lisp.

Macro: with-fixtures (fixtures &body body)

Shorthand macro to evaluate the body with the fixtures saved away.

See CALL-WITH-FIXTURES

Package

parachute.

Source

fixture.lisp.

Macro: with-forced-status ((status &optional description &rest format-args) &body tests)

Forces the requested status upon the tests in the body without evaluating any value-results.

Package

parachute.

Source

tester.lisp.

Macro: with-shuffling (&body body)

Causes each form in the body to be evaluated in random order each time the with-shuffling form is evaluated.

This is done by taking each form, wrapping it in a lambda, shuffling the list of
lambdas, and then funcalling each in the shuffled order.

See SHUFFLE

Package

parachute.

Source

toolkit.lisp.


5.1.3 Ordinary functions

Function: call-with-fixtures (function fixtures)

Calls the function with the given list of fixtures.

This ensures that the values are stored before the function is called and restored once the function is completed.

See CAPTURE-FIXTURES
See RESTORE-FIXTURES
See WITH-FIXTURE

Package

parachute.

Source

fixture.lisp.

Function: capture-fixtures (fixture)

Returns a list of fixtures for the given kind.

If the given name is a symbol that is not a keyword and has a package associated with it, then a list of a single fixture that captures every appropriate binding for the symbol is returned. Otherwise the name is interpreted as a package for which a list of fixtures for every symbol accessible in the package is returned.

See RESTORE-FIXTURES
See PACKAGE-FIXTURES
See DEFINE-FIXTURE-CAPTURE

Package

parachute.

Source

fixture.lisp.

Function: featurep (expr)

Returns T if the given feature expression matches the set of *FEATURES*

The expression follows the standard feature syntax. See 24.1.2.1 in the CLHS.

Package

parachute.

Source

toolkit.lisp.

Function: find-test (name &optional package-ish)

Finds the test by name if possible.

If the name is a symbol, the package defaults to the symbol’s package. If the name is a string, the package defaults to *PACKAGE*.
If no explicit package has been given and no test has been found, the search is automatically retried with the package set to *PACKAGE*. This should avoid confusion in the case of imported symbols and tests defined under the local package.

This function can also be used as a place in order to register a test. When a test is set, the preexisting test if any is first removed by REMOVE-TEST. This ensures that potentially removed options need to be properly updated within other affected tests. After that, the test is added to the list of children within its parent, if one is set. Finally the test is registered within the test index.

See REMOVE-TEST
See *TEST-INDEX*

Package

parachute.

Source

test.lisp.

Function: (setf find-test) (name &optional package-ish)
Package

parachute.

Source

test.lisp.

Function: package-fixtures (name)

Returns a list of fixtures for all symbols accessible in the given package.

Package

parachute.

Source

fixture.lisp.

Function: package-tests (package)

Returns a list of all the tests defined in the given package.

Signals an error if the PACKAGE cannot be resolved to a package object.

See *TEST-INDEXES*

Package

parachute.

Source

test.lisp.

Function: remove-all-tests-in-package (&optional package)

Remove all tests from PACKAGE (*package* by default).

Package

parachute.

Source

test.lisp.

Function: remove-test (name &optional package-ish)

Removes the test by name if possible.

When a test is removed, it is also automatically removed from its parent’s child list. However, weak references such as within a test’s dependencies cannot be updated as there is no backreference.

See FIND-TEST
See *TEST-INDEX*

Package

parachute.

Source

test.lisp.

Function: restore-fixtures (fixtures)

Restores the bindings stored in the fixtures to their saved values.

See CAPTURE-FIXTURES
See DEFINE-FIXTURE-RESTORE

Package

parachute.

Source

fixture.lisp.

Function: status-character (status)

Return the appropriate status indicator for a specific result status.

See *STATUS-INDICATORS*

Package

parachute.

Source

toolkit.lisp.

Function: test (designator &rest args &key report &allow-other-keys)

Run a test.

DESIGNATOR is resolved to a list of tests to run under a single report. You can specify the report class by the REPORT keyword argument. All other arguments are used as initargs for the REPORT creation.

After the report has been created, each test is run via EVAL-IN-CONTEXT. Finally SUMMARIZE is called on the report.

See REPORT
See RESOLVE-TESTS
See EVAL-IN-CONTEXT
See SUMMARIZE

Package

parachute.

Source

report.lisp.

Function: test-packages ()

Returns a list of all packages that define tests.

See *TEST-INDEXES*

Package

parachute.

Source

test.lisp.

Function: test-toplevel (designator/s &rest args)

Run tests as the toplevel.

This function calls TEST for each of the given test/s and the provided arguments. Once all tests have been completed, it will cause the implementation to quit.

The exit code will be 100 if any of the tests failed, and 0
if all of them passed. This is useful for cases like in automated continuous integration environments where the exit code determines success or failure of the build.

See TEST

Package

parachute.

Source

report.lisp.


5.1.4 Generic functions

Generic Reader: body (object)

The function that will be called to evaluate the result and obtain a value.

See VALUE
See VALUE-RESULT

Package

parachute.

Methods
Reader Method: body ((controlling-result controlling-result))

automatically generated reader method

Source

result.lisp.

Target Slot

body.

Reader Method: body ((group-result group-result))

automatically generated reader method

Source

result.lisp.

Target Slot

body.

Reader Method: body ((multiple-value-result multiple-value-result))

automatically generated reader method

Source

result.lisp.

Target Slot

body.

Reader Method: body ((value-result value-result))

automatically generated reader method

Source

result.lisp.

Target Slot

body.

Generic Writer: (setf body) (object)
Package

parachute.

Methods
Writer Method: (setf body) ((controlling-result controlling-result))

automatically generated writer method

Source

result.lisp.

Target Slot

body.

Writer Method: (setf body) ((group-result group-result))

automatically generated writer method

Source

result.lisp.

Target Slot

body.

Writer Method: (setf body) ((multiple-value-result multiple-value-result))

automatically generated writer method

Source

result.lisp.

Target Slot

body.

Writer Method: (setf body) ((value-result value-result))

automatically generated writer method

Source

result.lisp.

Target Slot

body.

Generic Function: check-evaluatable (context test)

Checks whether the thing is evaluatable in the context and signals an error if not.

This is primarily used to error out early on tests that are specified wrong.

See EVAL-IN-CONTEXT

Package

parachute.

Methods
Method: check-evaluatable (context (result group-result))
Source

result.lisp.

Method: check-evaluatable (context (result multiple-value-comparison-result))
Source

result.lisp.

Method: check-evaluatable (context (result comparison-result))
Source

result.lisp.

Method: check-evaluatable (context (result result))
Source

result.lisp.

Method: check-evaluatable (context (test test))
Source

test.lisp.

Generic Reader: child-status (object)

The status that the children of a controlling-result should be set to.

See CONTROLLING-RESULT

Package

parachute.

Methods
Reader Method: child-status ((controlling-result controlling-result))

automatically generated reader method

Source

result.lisp.

Target Slot

child-status.

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

parachute.

Methods
Writer Method: (setf child-status) ((controlling-result controlling-result))

automatically generated writer method

Source

result.lisp.

Target Slot

child-status.

Generic Function: children (object)

The list of child test instances.

Note that the return value of this will be shuffled randomly if the test is marked as non-serial. Child tests will be evaluated after the test itself.

See SERIAL
See TEST

Package

parachute.

Methods
Reader Method: children :around ((test test))
Source

test.lisp.

Target Slot

children.

Method: children ((test test))

automatically generated reader method

Source

test.lisp.

Generic Writer: (setf children) (object)
Package

parachute.

Methods
Writer Method: (setf children) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

children.

Generic Reader: comparison (object)

The comparison function designator that compares the expected and actual values of the test.

See COMPARISON-RESULT

Package

parachute.

Methods
Reader Method: comparison ((comparison-result comparison-result))

automatically generated reader method

Source

result.lisp.

Target Slot

comparison.

Generic Writer: (setf comparison) (object)
Package

parachute.

Methods
Writer Method: (setf comparison) ((comparison-result comparison-result))

automatically generated writer method

Source

result.lisp.

Target Slot

comparison.

Generic Reader: comparison-geq (object)

The value to which the comparison result must be GEQ to.

Defaults to T.

See COMPARISON-RESULT
See GEQ

Package

parachute.

Methods
Reader Method: comparison-geq ((comparison-result comparison-result))

automatically generated reader method

Source

result.lisp.

Target Slot

comparison-geq.

Generic Writer: (setf comparison-geq) (object)
Package

parachute.

Methods
Writer Method: (setf comparison-geq) ((comparison-result comparison-result))

automatically generated writer method

Source

result.lisp.

Target Slot

comparison-geq.

Generic Function: dependencies (test)

The logical combination of dependant tests.

DEPENDENCIES ::= (LOGOP DEPENDENCY*)
LOGOP ::= :OR | :AND | :NOT
DEPENDENCY ::= test-object | DEPENDENCIES

If a dependency is referenced that does not exist, an error is signalled. Dependant tests must be evaluated before the test itself.

See REFERENCED-DEPENDENCIES
See CHECK-DEPENDENCY-COMBINATION
See EVAL-DEPENDENCY-COMBINATION
See RESOLVE-DEPENDENCY-COMBINATION
See TEST

Package

parachute.

Methods
Method: dependencies ((test test))
Source

test.lisp.

Generic Reader: description (object)

The description of what the test/result is about as a string or NIL.

See RESULT
See TEST

Package

parachute.

Methods
Reader Method: description ((result result))

automatically generated reader method

Source

result.lisp.

Target Slot

description.

Reader Method: description ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

description.

Generic Writer: (setf description) (object)
Package

parachute.

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

automatically generated writer method

Source

result.lisp.

Target Slot

description.

Writer Method: (setf description) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

description.

Generic Reader: duration (object)

The duration the evaluation of the result object took in seconds or NIL.

This is automatically recorded in standard methods for EVAL-IN-CONTEXT. The value may be NIL if the test has not yet been evaluated at all.

See RESULT

Package

parachute.

Methods
Reader Method: duration ((result result))

automatically generated reader method

Source

result.lisp.

Target Slot

duration.

Generic Writer: (setf duration) (object)
Package

parachute.

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

automatically generated writer method

Source

result.lisp.

Target Slot

duration.

Generic Function: eval-in-context (context test)

Evaluates the thing within the given context.

This may seem like a rather generic description. In specific, this is mostly used in order to provide a customizable evaluation behaviour during the evaluation of tests under a given report. Which is to say that usually the context will be some report object and the thing being tested some kind of result or test instance.

See REPORT
See RESULT
See CHECK-EVALUATABLE

Package

parachute.

Methods
Method: eval-in-context :after ((report interactive) (result result))
Source

report.lisp.

Method: eval-in-context :around ((report interactive) (result result))
Source

report.lisp.

Method: eval-in-context ((report plain) (result result))
Source

report.lisp.

Method: eval-in-context ((report plain) (result finishing-result))
Source

report.lisp.

Method: eval-in-context ((report plain) (result value-result))
Source

report.lisp.

Method: eval-in-context :around ((report plain) (result result))
Source

report.lisp.

Method: eval-in-context :before ((report plain) (result parent-result))
Source

report.lisp.

Method: eval-in-context :around ((report quiet) (result result))
Source

report.lisp.

Method: eval-in-context ((context controlling-result) (result value-result))
Source

result.lisp.

Method: eval-in-context :before ((context controlling-result) (result result))
Source

result.lisp.

Method: eval-in-context :after (context (result controlling-result))
Source

result.lisp.

Method: eval-in-context (context (result controlling-result))
Source

result.lisp.

Method: eval-in-context (context (result test-result))
Source

result.lisp.

Method: eval-in-context :around (context (result test-result))
Source

result.lisp.

Method: eval-in-context (context (result group-result))
Source

result.lisp.

Method: eval-in-context :after (context (result parent-result))
Source

result.lisp.

Method: eval-in-context :around (context (result parent-result))
Source

result.lisp.

Method: eval-in-context (context (result comparison-result))
Source

result.lisp.

Method: eval-in-context (context (result finishing-result))
Source

result.lisp.

Method: eval-in-context (context (result multiple-value-result))
Source

result.lisp.

Method: eval-in-context (context (result value-result))
Source

result.lisp.

Method: eval-in-context :around (context (result result))
Source

result.lisp.

Method: eval-in-context :around (context thing)
Source

result.lisp.

Method: eval-in-context :after (context (test test))
Source

test.lisp.

Method: eval-in-context (context (test test))
Source

test.lisp.

Method: eval-in-context :around (context (test test))
Source

test.lisp.

Generic Reader: expected (object)

A value that should be equal (under some predicate) to what the test evaluates to.

See COMPARISON-RESULT

Package

parachute.

Methods
Reader Method: expected ((comparison-result comparison-result))

automatically generated reader method

Source

result.lisp.

Target Slot

expected.

Generic Writer: (setf expected) (object)
Package

parachute.

Methods
Writer Method: (setf expected) ((comparison-result comparison-result))

automatically generated writer method

Source

result.lisp.

Target Slot

expected.

Generic Reader: expression (object)

The expression that the result object is about.

See RESULT

Package

parachute.

Methods
Reader Method: expression ((result result))

automatically generated reader method

Source

result.lisp.

Target Slot

expression.

Generic Writer: (setf expression) (object)
Package

parachute.

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

automatically generated writer method

Source

result.lisp.

Target Slot

expression.

Generic Function: find-child-result (test result)

Attempts to find the result object associated with the given test.

This simply tests by EQ against the EXPRESSION of each child within the result.

See PARENT-RESULT

Package

parachute.

Methods
Method: find-child-result (test (result parent-result))
Source

result.lisp.

Generic Reader: fixtures (object)

The list of fixed symbols or packages.

See WITH-FIXTURE
See TEST

Package

parachute.

Methods
Reader Method: fixtures ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

fixtures.

Generic Writer: (setf fixtures) (object)
Package

parachute.

Methods
Writer Method: (setf fixtures) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

fixtures.

Generic Function: format-result (result type)

Formats the result into the requested representation as a string.

The representation type can, by default, be either :ONELINE or :EXTENSIVE.

See RESULT

Package

parachute.

Methods
Method: format-result ((result controlling-result) (type (eql :oneline)))
Source

result.lisp.

Method: format-result ((result test-result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result test-result) (type (eql :oneline)))
Source

result.lisp.

Method: format-result ((result group-result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result group-result) (type (eql :oneline)))
Source

result.lisp.

Method: format-result ((result multiple-value-comparison-result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result comparison-result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result finishing-result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result result) (type (eql :extensive)))
Source

result.lisp.

Method: format-result ((result result) (type (eql :oneline)))
Source

result.lisp.

Generic Reader: home (object)

The home package of the test.

See TEST

Package

parachute.

Methods
Reader Method: home ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

home.

Generic Reader: name (object)

The name of the test, which is always a string.

See TEST

Package

parachute.

Methods
Reader Method: name ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

name.

Generic Reader: output (object)

The stream that the PLAIN report outputs to during REPORT-ON and SUMMARIZE.

See PLAIN
See REPORT-ON
See SUMMARIZE

Package

parachute.

Methods
Reader Method: output ((plain plain))

automatically generated reader method

Source

report.lisp.

Target Slot

output.

Generic Writer: (setf output) (object)
Package

parachute.

Methods
Writer Method: (setf output) ((plain plain))

automatically generated writer method

Source

report.lisp.

Target Slot

output.

Generic Reader: parent (object)

The parent test object, if any.

If a test has a parent, then it must also itself be contained in the parent’s children list.

See TEST

Package

parachute.

Methods
Reader Method: parent ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

parent.

Generic Writer: (setf parent) (object)
Package

parachute.

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

automatically generated writer method

Source

test.lisp.

Target Slot

parent.

Generic Reader: referenced-dependencies (object)

The logical combination of test designators that reference a dependant test.

DEPENDENCIES ::= (DEPENDENCY*) | (LOGOP DEPENDENCY*)
LOGOP ::= :OR | :AND | :NOT
DEPENDENCY ::= test-name | (home test-name) | DEPENDENCIES

See DEPENDENCIES
See TEST

Package

parachute.

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

automatically generated reader method

Source

test.lisp.

Target Slot

dependencies.

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

parachute.

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

automatically generated writer method

Source

test.lisp.

Target Slot

dependencies.

Generic Reader: referenced-skips (object)

The list of test designators that reference a skipped test.

See SKIPPED-CHILDREN
See TEST

Package

parachute.

Methods
Reader Method: referenced-skips ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

skipped-children.

Generic Writer: (setf referenced-skips) (object)
Package

parachute.

Methods
Writer Method: (setf referenced-skips) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

skipped-children.

Generic Function: report-on (thing report)

Causes the result to be printed to standard output under the formatting of the report.

See REPORT
See RESULT

Package

parachute.

Methods
Method: report-on ((result result) (report plain))
Source

report.lisp.

Method: report-on :after (thing (report plain))
Source

report.lisp.

Method: report-on :before ((result result) (report plain))
Source

report.lisp.

Method: report-on :around (thing (report plain))
Source

report.lisp.

Generic Function: result-for-testable (test context)

Returns an appropriate RESULT instance for the given testable and context.

You should specialize this if you need special kinds of result types for your report.

See RESULT

Package

parachute.

Methods
Method: result-for-testable ((test test) (result parent-result))
Source

result.lisp.

Method: result-for-testable ((test test) context)
Source

result.lisp.

Generic Reader: results (object)

The vector of child results within the parent.

See PARENT-RESULT
See ADD-CHILD

Package

parachute.

Methods
Reader Method: results ((parent-result parent-result))

automatically generated reader method

Source

result.lisp.

Target Slot

results.

Generic Writer: (setf results) (object)
Package

parachute.

Methods
Writer Method: (setf results) ((parent-result parent-result))

automatically generated writer method

Source

result.lisp.

Target Slot

results.

Generic Function: results-with-status (status result)

Returns a list of results that are a child of the result and have the requested status.

See PARENT-RESULT

Package

parachute.

Methods
Method: results-with-status (status (result parent-result))
Source

result.lisp.

Generic Reader: serial (object)

Whether the tests and children should be evaluated in order, or randomly.

This affects the return values of TESTS and CHILDREN.

See CHILDREN
See TESTS
See TEST

Package

parachute.

Methods
Reader Method: serial ((test test))

automatically generated reader method

Source

test.lisp.

Target Slot

serial.

Generic Writer: (setf serial) (object)
Package

parachute.

Methods
Writer Method: (setf serial) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

serial.

Generic Function: skipped-children (test)

The list of the children that should be skipped.

If a child is referenced that does not exist, an error is signalled. If a child is within this list, it will not be evaluated after the test and instead be marked as skipped automatically.

See REFERENCED-SKIPS
See TEST

Package

parachute.

Methods
Method: skipped-children ((test test))
Source

test.lisp.

Generic Reader: status (object)

The status of the result object.

Should be one of :UNKNOWN :FAILED :PASSED :SKIPPED. By default after initialization the status is :UNKNOWN. The status is automatically changed to :PASSED if the result is still :UNKNOWN after EVAL-IN-CONTEXT completes.

See RESULT

Package

parachute.

Methods
Reader Method: status ((result result))

automatically generated reader method

Source

result.lisp.

Target Slot

status.

Generic Writer: (setf status) (object)
Package

parachute.

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

automatically generated writer method

Source

result.lisp.

Target Slot

status.

Generic Function: summarize (report)

Should cause the report to produce some kind of summary.

How this summary is presented and what is contained in it is up to the report itself.

See REPORT.

Package

parachute.

Methods
Method: summarize ((report largescale))
Source

report.lisp.

Method: summarize ((report plain))
Source

report.lisp.

Method: summarize ((report report))
Source

report.lisp.

Generic Function: tests (object)

The list of functions to execute in order to actually perform the tests.

Note that the return value of this will be shuffled randomly if the test is marked as non-serial.

See SERIAL
See TEST

Package

parachute.

Methods
Reader Method: tests :around ((test test))
Source

test.lisp.

Target Slot

tests.

Method: tests ((test test))

automatically generated reader method

Source

test.lisp.

Generic Writer: (setf tests) (object)
Package

parachute.

Methods
Writer Method: (setf tests) ((test test))

automatically generated writer method

Source

test.lisp.

Target Slot

tests.

Generic Function: tests-with-status (status report)

Returns a list of TEST objects that have been evaluated and whose reports have the requested status.

See REPORT
See RESULTS-WITH-STATUS

Package

parachute.

Methods
Method: tests-with-status (status (report report))
Source

report.lisp.

Generic Reader: time-limit (object)

The time limit of the test, if any.

In order for the test to succeed, the evaluation must succeed before the time limit is reached. Otherwise the test is marked as having failed.

See TEST

Package

parachute.

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

automatically generated reader method

Source

test.lisp.

Target Slot

time-limit.

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

parachute.

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

automatically generated writer method

Source

test.lisp.

Target Slot

time-limit.

Generic Reader: value (object)

The value of the result object that is obtained by running its body.

See BODY
See VALUE-RESULT

Package

parachute.

Methods
Reader Method: value ((multiple-value-result multiple-value-result))

automatically generated reader method

Source

result.lisp.

Target Slot

value.

Reader Method: value ((value-result value-result))

automatically generated reader method

Source

result.lisp.

Target Slot

value.

Generic Writer: (setf value) (object)
Package

parachute.

Methods
Writer Method: (setf value) ((multiple-value-result multiple-value-result))

automatically generated writer method

Source

result.lisp.

Target Slot

value.

Writer Method: (setf value) ((value-result value-result))

automatically generated writer method

Source

result.lisp.

Target Slot

value.

Generic Function: value-expected-p (result value expected)
Package

parachute.

Source

result.lisp.

Methods
Method: value-expected-p ((result multiple-value-comparison-result) value expected)
Method: value-expected-p ((result comparison-result) value expected)
Generic Reader: value-form (object)

A literal representation of the form that produces the value for the test.

See COMPARISON-RESULT

Package

parachute.

Methods
Reader Method: value-form ((comparison-result comparison-result))

automatically generated reader method

Source

result.lisp.

Target Slot

value-form.

Generic Writer: (setf value-form) (object)
Package

parachute.

Methods
Writer Method: (setf value-form) ((comparison-result comparison-result))

automatically generated writer method

Source

result.lisp.

Target Slot

value-form.


5.1.5 Standalone methods

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

result.lisp.

Method: print-object ((result result) stream)
Source

result.lisp.

Method: print-object ((test test) stream)
Source

test.lisp.

Method: print-object ((report report) stream)
Source

report.lisp.

Method: shared-initialize :after ((test test) slots &key parent home name)
Source

test.lisp.


5.1.6 Classes

Class: comparison-result

A result that compares against an expected value by some kind of comparator.

This result sets its status based on the boolean return value of a test of its value against an expected, preset value.

See VALUE-FORM
See EXPECTED
See COMPARISON
See COMPARISON-GEQ
See VALUE-RESULT
See VALUE-EXPECTED-P

Package

parachute.

Source

result.lisp.

Direct superclasses

value-result.

Direct subclasses

multiple-value-comparison-result.

Direct methods
Direct Default Initargs
InitargValue
:value-formunknown
:expected(quote (not null))
:comparison(quote typep)
:comparison-geqt
Direct slots
Slot: value-form
Initargs

:value-form

Readers

value-form.

Writers

(setf value-form).

Slot: expected
Initargs

:expected

Readers

expected.

Writers

(setf expected).

Slot: comparison
Initargs

:comparison

Readers

comparison.

Writers

(setf comparison).

Slot: comparison-geq
Initargs

:comparison-geq

Readers

comparison-geq.

Writers

(setf comparison-geq).

Class: controlling-result

A result that will force a status upon the tests run in its body without performing the tests for real.

This works through a hack, at this point. When the controlling-result
is evaluated, it binds *CONTEXT* to itself and *REAL-CONTEXT* to the
actual context. It then calls the BODY.

When a result is evaluated within its body, it then ADD-RESULTs that
to the real context. If it is a value-result, the body function thereof
is replaced by a function that changes the result’s status to whatever
CHILD-STATUS is. It then evaluates the value-result in the real context.
Once that returns, the value-result’s value slot is made unbound again.

See CHILD-STATUS

Package

parachute.

Source

result.lisp.

Direct superclasses

parent-result.

Direct methods
Direct slots
Slot: child-status
Initargs

:child-status

Readers

child-status.

Writers

(setf child-status).

Slot: body
Initargs

:body

Readers

body.

Writers

(setf body).

Class: finishing-result

A result that only passes if its evaluation proceeds without escaping.

See VALUE-RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses

value-result.

Direct methods
Class: group-result

A result object for a group of test forms.

Simply evaluates the BODY of tests. Primarily intended for output control.

See BODY
See PARENT-RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses

parent-result.

Direct methods
Direct slots
Slot: body
Initargs

:body

Readers

body.

Writers

(setf body).

Class: interactive

An interactive test report that shows the debugger on every failure, with restarts that allow you to decide what to do next.

See REPORT

Package

parachute.

Source

report.lisp.

Direct superclasses

report.

Direct methods
Class: largescale

A plain-text report that prints a summary suitable for large-scale test suites.

This differs from the basic SUMMARY in that it reports percentages,
and only prints the first 5 failures if there are any.

See SUMMARY

Package

parachute.

Source

report.lisp.

Direct superclasses

summary.

Direct methods

summarize.

Class: multiple-value-comparison-result

A result that compares against a list of expected values and comparators.

This test sets its status to :passed if, and only if, for every value pair from the VALUE, EXPECTED, and COMPARISON lists, the GEQ test succeeds. In other words, if we have VALUES (1 "2"), EXPECTED (1.0 "2"),
COMPARISON (= equal), then the result would be :passed.

See VALUE-FORM
See EXPECTED
See COMPARISON
See COMPARISON-GEQ
See MULTIPLE-VALUE-RESULT
See COMPARISON-RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses
Direct methods
Direct Default Initargs
InitargValue
:expected(quote ((not null)))
:comparison(quote (typep))
Class: multiple-value-result

A result that carries a list of test result values.

Typically the VALUE slot is only set once the result is evaluated. Note that if the VALUE slot is bound at the time that the result is evaluated, the BODY will not be run.

See BODY
See VALUE
See RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses

value-result.

Direct subclasses

multiple-value-comparison-result.

Direct methods
Direct Default Initargs
InitargValue
:body(error body required.)
Direct slots
Slot: value
Initargs

:value

Readers

value.

Writers

(setf value).

Slot: body
Initargs

:body

Readers

body.

Writers

(setf body).

Class: parent-result

A result that does not directly perform a test, but rather serves as an aggregate for multiple tests.

This result will set its status to :FAILED automatically if it notices that
after evaluation one or more of its child results have the status :FAILED.

See RESULTS
See RESULT
See FIND-CHILD-RESULT
See RESULTS-WITH-STATUS
See ADD-RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses

result.

Direct subclasses
Direct methods
Direct slots
Slot: results
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

results.

Writers

(setf results).

Class: plain

A plain-text report that prints test results as they go by as well as a summary of the failures at the end.

See REPORT
See OUTPUT
See REPORT-ON

Package

parachute.

Source

report.lisp.

Direct superclasses

report.

Direct subclasses

summary.

Direct methods
Direct Default Initargs
InitargValue
:stream*standard-output*
:show-listingt
Direct slots
Slot: output
Initargs

:stream, :output

Readers

output.

Writers

(setf output).

Slot: show-listing-p
Initargs

:show-listing

Readers

show-listing-p.

Writers

(setf show-listing-p).

Class: quiet

A quiet report that doesn’t report nor do anything special.

Simply returns the report object on SUMMARIZE.

See REPORT

Package

parachute.

Source

report.lisp.

Direct superclasses

report.

Direct methods

eval-in-context.

Class: report

Base class for all report objects.

Reports are responsible for gathering and representing the results of a test evaluation. The manner in which the results are presented to the user is up to the test in question.

See PARENT-RESULT
See SUMMARIZE

Package

parachute.

Source

report.lisp.

Direct superclasses

parent-result.

Direct subclasses
Direct methods
Class: result

Base container object for test results of any kind.

A result always has:
EXPRESSION – An expression describing what this result is about. STATUS – One of :UNKNOWN :FAILED :PASSED :SKIPPED.
DURATION – The duration (in seconds) the evaluation took, or NIL. DESCRIPTION – A string describing the result, or NIL.

See EXPRESSION
See STATUS
See DURATION
See DESCRIPTION

Package

parachute.

Source

result.lisp.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:expression(error expression required.)
:statusunknown
:durationnil
:descriptionnil
Direct slots
Slot: expression
Initargs

:expression

Readers

expression.

Writers

(setf expression).

Slot: status
Initargs

:status

Readers

status.

Writers

(setf status).

Slot: duration
Initargs

:duration

Readers

duration.

Writers

(setf duration).

Slot: description
Initargs

:description

Readers

description.

Writers

(setf description).

Class: summary

A plain-text report that prints only a summary at the end.

See PLAIN
See REPORT
See OUTPUT
See REPORT-ON

Package

parachute.

Source

report.lisp.

Direct superclasses

plain.

Direct subclasses

largescale.

Direct Default Initargs
InitargValue
:show-listingnil
Class: test

Container for test collections.

Manages all the data that ties different collections together and manages the various options you might want to have for tests.

Note that merely initializing a test instance will not register it to be found by FIND-TEST. It will also not tie it in with the rest of the tests. An error will be signalled, if a parent is designated that does not exist, and warnings will be signalled if dependencies are designated that do not exist. The PARENT may be either a test designator name, which will be resolved within HOME, or a list of a package designator to use as the HOME and a name.

In order for the test to be tied in and registered to be findable, use (SETF (FIND-TEST name home) test). In order to remove it, simply use REMOVE-TEST.

See NAME
See HOME
See DESCRIPTION
See PARENT
See CHILDREN
See DEPENDENCIES
See REFERENCED-DEPENDENCIES
See FIXTURES
See TIME-LIMIT
See SKIPPED-CHILDREN
See REFERENCED-SKIPS
See TESTS
See SERIAL
See FIND-TEST
See REMOVE-TEST
See DEFINE-TEST

Package

parachute.

Source

test.lisp.

Direct methods
Direct Default Initargs
InitargValue
:name(error name required.)
:home*package*
:descriptionnil
:parentnil
:dependenciesnil
:fixturesnil
:time-limitnil
:skipped-childrennil
:serialt
:testsnil
Direct slots
Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.

Slot: home
Initargs

:home

Readers

home.

Writers

This slot is read-only.

Slot: description
Initargs

:description

Readers

description.

Writers

(setf description).

Slot: parent
Initargs

:parent

Readers

parent.

Writers

(setf parent).

Slot: children
Readers

children.

Writers

(setf children).

Slot: dependencies
Initargs

:dependencies, :depends-on

Readers

referenced-dependencies.

Writers

(setf referenced-dependencies).

Slot: fixtures
Initargs

:fixtures, :fix

Readers

fixtures.

Writers

(setf fixtures).

Slot: time-limit
Initargs

:time-limit

Readers

time-limit.

Writers

(setf time-limit).

Slot: skipped-children
Initargs

:skipped-children, :skip

Readers

referenced-skips.

Writers

(setf referenced-skips).

Slot: tests
Initargs

:tests

Readers

tests.

Writers

(setf tests).

Slot: serial
Initargs

:serial

Readers

serial.

Writers

(setf serial).

Class: test-result

A result object for tests.

This takes care of properly evaluating the test by following these steps: 1. Run all tests in the test’s DEPENDENCIES as per EVAL-DEPENDENCY-COMBINATION 2. Check that all dependencies have a :PASSED status as per the dependency combination by running CHECK-DEPENDENCY-COMBINATION
3. For each child in the test’s CHILDREN
create a result by RESULT-FOR-TESTABLE
if the child is part of the test’s SKIPPED-CHILDREN
mark its result as :SKIPPED and EVAL-IN-CONTEXT it.
Otherwise EVAL-IN-CONTEXT the child’s result directly.

The methods implemented by PARENT-RESULT and RESULT will in turn
take care to implement proper status setting and avoiding duplicate evaluation.

See PARENT-RESULT
See EVAL-DEPENDENCY-COMBINATION
See CHECK-DEPENDENCY-COMBINATION

Package

parachute.

Source

result.lisp.

Direct superclasses

parent-result.

Direct methods
Class: value-result

A result that carries some kind of test result value.

Typically the VALUE slot is only set once the result is evaluated. Note that if the VALUE slot is bound at the time that the result is evaluated, the BODY will not be run.

See BODY
See VALUE
See RESULT

Package

parachute.

Source

result.lisp.

Direct superclasses

result.

Direct subclasses
Direct methods
Direct Default Initargs
InitargValue
:body(error body required.)
Direct slots
Slot: value
Initargs

:value

Readers

value.

Writers

(setf value).

Slot: body
Initargs

:body

Readers

body.

Writers

(setf body).


5.2 Internals


5.2.1 Special variables

Special Variable: *level*
Package

parachute.

Source

report.lisp.

Special Variable: *real-context*

Captures the context before the controlling-result has to take over.

See CONTROLLING-RESULT

Package

parachute.

Source

result.lisp.

Special Variable: *test-indexes*

A hash-table from packages to hash-tables from strings to test instances.

Contains the maps of packages to tests.

Package

parachute.

Source

test.lisp.


5.2.2 Macros

Macro: capture-error (form &optional condition)

Returns the condition signalled by the form, or NIL if none was signalled.

By default only subconditions of ERROR are caught.

Package

parachute.

Source

toolkit.lisp.

Macro: lformat (format &rest args)
Package

parachute.

Source

report.lisp.

Macro: maybe-do-not-silence-errors (&body body)
Package

parachute.

Source

report.lisp.

Macro: with-timeout (timeout &body body)
Package

parachute.

Source

toolkit.lisp.


5.2.3 Ordinary functions

Function: call-compile (form)

Compiles the form with muffled warnings and calls the resulting function.

Package

parachute.

Source

toolkit.lisp.

Function: check-dependency-combination (status context combination)

Checks each test in the dependency combination against the given status.

This traverses the dependency combination, retrieves the result from the context for each test, compares its STATUS against the requested one, and then logically combines the results thereof according to the combinator’s operation.

An error is signalled if the structure is violated.

See RESOLVE-DEPENDENCY-COMBINATION
See STATUS
See FIND-CHILD-RESULT

Package

parachute.

Source

test.lisp.

Function: destructure-is-values-body (body)
Package

parachute.

Source

tester.lisp.

Function: ensure-test (class &rest initargs)
Package

parachute.

Source

test.lisp.

Function: eval-dependency-combination (context combination)

Evaluates the dependency combination under the given context.

This simply traverses the structure recursively and calls EVAL-IN-CONTEXT on each test object.

An error is signalled if the structure is violated.

See RESOLVE-DEPENDENCY-COMBINATION
See EVAL-IN-CONTEXT

Package

parachute.

Source

test.lisp.

Function: filter-test-results (results)
Package

parachute.

Source

report.lisp.

Function: geq (value expected)

Returns true if the value is of the expected general boolean.

More specifically, the following table is followed:
VALUE EXPECTED RESULT
T T T
NIL T NIL
NIL NIL T
T NIL NIL

Package

parachute.

Source

toolkit.lisp.

Function: locked-package-p (package)

Returns T if the given package is (assumed to be) locked and whose function bindings should thus not be changed.

Package

parachute.

Source

toolkit.lisp.

Function: maybe-quote (expression)

Quotes the expression if it is necessary to do so.

It is considered unnecessary to quote the expression if:
- The expression isnt an atom
- It is constant under CONSTANTP

Implementations other than SBCL and ECL are "out of luck" when it comes to quasiquoting. Generally you just shouldn’t quasiquote for this anyway since it is most likely useful for packing a value in a macro where the lexical references could not be resolved.

Package

parachute.

Source

toolkit.lisp.

Function: maybe-unquote (expression)

Unquotes the expression if it is plausible to do so.

If the form is a cons, it is EVALed. This is the only way I can think of to have any kind of hope to unquote quasiquoted expressions portably. Naturally this will error if the quasiquote contains any form of lexical references that are unresolvable.

Package

parachute.

Source

toolkit.lisp.

Function: number-suffix (n)
Package

parachute.

Source

toolkit.lisp.

Function: print-oneline (thing &optional output)

Attempts to print the given object to the stream designator in one line.

This is mostly to avoid the standard printer’s annoying line break behaviour as it over-eagerly inserts line breaks and makes the output spammy, especially for the plain report. This prints vectors (not strings) and lists on one line for sure. Everything else might still incur line breaks, but I believe that that is mostly outside of my control.

Package

parachute.

Source

toolkit.lisp.

Function: removef (place &rest indicators)

Returns a new plist with the key/value pairs of the indicators removed.

Package

parachute.

Source

toolkit.lisp.

Function: resolve-dependency-combination (combination test)

Resolves the dependency combination COMBINATION for the TEST object.

This turns all referenced test in the structure to actual test instances.

COMBINATION ::= (LOGOP DEPENDENCY*)
LOGOP ::= :OR | :AND | :NOT
DEPENDENCY ::= test-name | (home test-name) | DEPENDENCY

If a dependency that does not exist is referenced or the above structure is violated, an error is signalled.

See REFERENCED-DEPENDENCIES
See FIND-TEST

Package

parachute.

Source

test.lisp.

Function: resolve-tests (designator)

Resolves the given test designator into a list of tests.

The designator can be of type
LIST – RESOLVE-TESTS is called on each element of the list and the results are concatenated together. PACKAGE – Returns a list of all tests in the given package. SYMBOL
STRING – If the name resolves to a test by FIND-TEST, a list only containing that test is returned. If the name resolves to a package by FIND-PACKAGE, a list of all tests in the package is returned. If neither can be found, an error is signalled.

See FIND-TEST
See PACKAGE-TESTS

Package

parachute.

Source

report.lisp.

Function: retain (argument)
Package

parachute.

Source

toolkit.lisp.

Function: shuffle (seq)

Shuffles the given sequence into a new one where the elements have uniformly distributed random placement.

Package

parachute.

Source

toolkit.lisp.

Function: test-index (name package-ish)

Returns the map for names to test instances.

See FIND-TEST

Package

parachute.

Source

test.lisp.

Function: try-compile (form &optional intercept)
Package

parachute.

Source

toolkit.lisp.


5.2.4 Generic functions

Generic Function: add-result (result parent)

Adds the child to the parent’s results if it is not a part already.

See RESULTS
See PARENT-RESULT

Package

parachute.

Methods
Method: add-result ((result result) (parent parent-result))
Source

result.lisp.

Generic Function: result-complete-p (result)
Package

parachute.

Methods
Method: result-complete-p ((result result))
Source

result.lisp.

Generic Reader: show-listing-p (object)
Package

parachute.

Methods
Reader Method: show-listing-p ((plain plain))

automatically generated reader method

Source

report.lisp.

Target Slot

show-listing-p.

Generic Writer: (setf show-listing-p) (object)
Package

parachute.

Methods
Writer Method: (setf show-listing-p) ((plain plain))

automatically generated writer method

Source

report.lisp.

Target Slot

show-listing-p.


5.2.5 Types

Type: timeout ()
Package

parachute.

Source

toolkit.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

(
(setf body): Public generic functions
(setf body): Public generic functions
(setf body): Public generic functions
(setf body): Public generic functions
(setf body): Public generic functions
(setf child-status): Public generic functions
(setf child-status): Public generic functions
(setf children): Public generic functions
(setf children): Public generic functions
(setf comparison): Public generic functions
(setf comparison): Public generic functions
(setf comparison-geq): Public generic functions
(setf comparison-geq): Public generic functions
(setf description): Public generic functions
(setf description): Public generic functions
(setf description): Public generic functions
(setf duration): Public generic functions
(setf duration): Public generic functions
(setf expected): Public generic functions
(setf expected): Public generic functions
(setf expression): Public generic functions
(setf expression): Public generic functions
(setf find-test): Public ordinary functions
(setf fixtures): Public generic functions
(setf fixtures): Public generic functions
(setf output): Public generic functions
(setf output): Public generic functions
(setf parent): Public generic functions
(setf parent): Public generic functions
(setf referenced-dependencies): Public generic functions
(setf referenced-dependencies): Public generic functions
(setf referenced-skips): Public generic functions
(setf referenced-skips): Public generic functions
(setf results): Public generic functions
(setf results): Public generic functions
(setf serial): Public generic functions
(setf serial): Public generic functions
(setf show-listing-p): Private generic functions
(setf show-listing-p): Private generic functions
(setf status): Public generic functions
(setf status): Public generic functions
(setf tests): Public generic functions
(setf tests): Public generic functions
(setf time-limit): Public generic functions
(setf time-limit): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf value): Public generic functions
(setf value-form): Public generic functions
(setf value-form): Public generic functions

A
add-result: Private generic functions
add-result: Private generic functions

B
body: Public generic functions
body: Public generic functions
body: Public generic functions
body: Public generic functions
body: Public generic functions

C
call-compile: Private ordinary functions
call-with-fixtures: Public ordinary functions
capture-error: Private macros
capture-fixtures: Public ordinary functions
check-dependency-combination: Private ordinary functions
check-evaluatable: Public generic functions
check-evaluatable: Public generic functions
check-evaluatable: Public generic functions
check-evaluatable: Public generic functions
check-evaluatable: Public generic functions
check-evaluatable: Public generic functions
child-status: Public generic functions
child-status: Public generic functions
children: Public generic functions
children: Public generic functions
children: Public generic functions
comparison: Public generic functions
comparison: Public generic functions
comparison-geq: Public generic functions
comparison-geq: Public generic functions

D
define-fixture-capture: Public macros
define-fixture-restore: Public macros
define-test: Public macros
define-test+run: Public macros
define-test+run-interactively: Public macros
dependencies: Public generic functions
dependencies: Public generic functions
description: Public generic functions
description: Public generic functions
description: Public generic functions
destructure-is-values-body: Private ordinary functions
duration: Public generic functions
duration: Public generic functions

E
ensure-test: Private ordinary functions
eval-dependency-combination: Private ordinary functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
eval-in-context: Public generic functions
expected: Public generic functions
expected: Public generic functions
expression: Public generic functions
expression: Public generic functions

F
fail: Public macros
fail-compile: Public macros
false: Public macros
featurep: Public ordinary functions
filter-test-results: Private ordinary functions
find-child-result: Public generic functions
find-child-result: Public generic functions
find-test: Public ordinary functions
finish: Public macros
fixtures: Public generic functions
fixtures: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
format-result: Public generic functions
Function, (setf find-test): Public ordinary functions
Function, call-compile: Private ordinary functions
Function, call-with-fixtures: Public ordinary functions
Function, capture-fixtures: Public ordinary functions
Function, check-dependency-combination: Private ordinary functions
Function, destructure-is-values-body: Private ordinary functions
Function, ensure-test: Private ordinary functions
Function, eval-dependency-combination: Private ordinary functions
Function, featurep: Public ordinary functions
Function, filter-test-results: Private ordinary functions
Function, find-test: Public ordinary functions
Function, geq: Private ordinary functions
Function, locked-package-p: Private ordinary functions
Function, maybe-quote: Private ordinary functions
Function, maybe-unquote: Private ordinary functions
Function, number-suffix: Private ordinary functions
Function, package-fixtures: Public ordinary functions
Function, package-tests: Public ordinary functions
Function, print-oneline: Private ordinary functions
Function, remove-all-tests-in-package: Public ordinary functions
Function, remove-test: Public ordinary functions
Function, removef: Private ordinary functions
Function, resolve-dependency-combination: Private ordinary functions
Function, resolve-tests: Private ordinary functions
Function, restore-fixtures: Public ordinary functions
Function, retain: Private ordinary functions
Function, shuffle: Private ordinary functions
Function, status-character: Public ordinary functions
Function, test: Public ordinary functions
Function, test-index: Private ordinary functions
Function, test-packages: Public ordinary functions
Function, test-toplevel: Public ordinary functions
Function, try-compile: Private ordinary functions

G
Generic Function, (setf body): Public generic functions
Generic Function, (setf child-status): Public generic functions
Generic Function, (setf children): Public generic functions
Generic Function, (setf comparison): Public generic functions
Generic Function, (setf comparison-geq): Public generic functions
Generic Function, (setf description): Public generic functions
Generic Function, (setf duration): Public generic functions
Generic Function, (setf expected): Public generic functions
Generic Function, (setf expression): Public generic functions
Generic Function, (setf fixtures): Public generic functions
Generic Function, (setf output): Public generic functions
Generic Function, (setf parent): Public generic functions
Generic Function, (setf referenced-dependencies): Public generic functions
Generic Function, (setf referenced-skips): Public generic functions
Generic Function, (setf results): Public generic functions
Generic Function, (setf serial): Public generic functions
Generic Function, (setf show-listing-p): Private generic functions
Generic Function, (setf status): Public generic functions
Generic Function, (setf tests): Public generic functions
Generic Function, (setf time-limit): Public generic functions
Generic Function, (setf value): Public generic functions
Generic Function, (setf value-form): Public generic functions
Generic Function, add-result: Private generic functions
Generic Function, body: Public generic functions
Generic Function, check-evaluatable: Public generic functions
Generic Function, child-status: Public generic functions
Generic Function, children: Public generic functions
Generic Function, comparison: Public generic functions
Generic Function, comparison-geq: Public generic functions
Generic Function, dependencies: Public generic functions
Generic Function, description: Public generic functions
Generic Function, duration: Public generic functions
Generic Function, eval-in-context: Public generic functions
Generic Function, expected: Public generic functions
Generic Function, expression: Public generic functions
Generic Function, find-child-result: Public generic functions
Generic Function, fixtures: Public generic functions
Generic Function, format-result: Public generic functions
Generic Function, home: Public generic functions
Generic Function, name: Public generic functions
Generic Function, output: Public generic functions
Generic Function, parent: Public generic functions
Generic Function, referenced-dependencies: Public generic functions
Generic Function, referenced-skips: Public generic functions
Generic Function, report-on: Public generic functions
Generic Function, result-complete-p: Private generic functions
Generic Function, result-for-testable: Public generic functions
Generic Function, results: Public generic functions
Generic Function, results-with-status: Public generic functions
Generic Function, serial: Public generic functions
Generic Function, show-listing-p: Private generic functions
Generic Function, skipped-children: Public generic functions
Generic Function, status: Public generic functions
Generic Function, summarize: Public generic functions
Generic Function, tests: Public generic functions
Generic Function, tests-with-status: Public generic functions
Generic Function, time-limit: Public generic functions
Generic Function, value: Public generic functions
Generic Function, value-expected-p: Public generic functions
Generic Function, value-form: Public generic functions
geq: Private ordinary functions
group: Public macros

H
home: Public generic functions
home: Public generic functions

I
initialize-instance: Public standalone methods
is: Public macros
is-values: Public macros
isnt: Public macros
isnt-values: Public macros

L
lformat: Private macros
locked-package-p: Private ordinary functions

M
Macro, capture-error: Private macros
Macro, define-fixture-capture: Public macros
Macro, define-fixture-restore: Public macros
Macro, define-test: Public macros
Macro, define-test+run: Public macros
Macro, define-test+run-interactively: Public macros
Macro, fail: Public macros
Macro, fail-compile: Public macros
Macro, false: Public macros
Macro, finish: Public macros
Macro, group: Public macros
Macro, is: Public macros
Macro, is-values: Public macros
Macro, isnt: Public macros
Macro, isnt-values: Public macros
Macro, lformat: Private macros
Macro, maybe-do-not-silence-errors: Private macros
Macro, of-type: Public macros
Macro, skip: Public macros
Macro, skip-on: Public macros
Macro, true: Public macros
Macro, with-fixtures: Public macros
Macro, with-forced-status: Public macros
Macro, with-shuffling: Public macros
Macro, with-timeout: Private macros
maybe-do-not-silence-errors: Private macros
maybe-quote: Private ordinary functions
maybe-unquote: Private ordinary functions
Method, (setf body): Public generic functions
Method, (setf body): Public generic functions
Method, (setf body): Public generic functions
Method, (setf body): Public generic functions
Method, (setf child-status): Public generic functions
Method, (setf children): Public generic functions
Method, (setf comparison): Public generic functions
Method, (setf comparison-geq): Public generic functions
Method, (setf description): Public generic functions
Method, (setf description): Public generic functions
Method, (setf duration): Public generic functions
Method, (setf expected): Public generic functions
Method, (setf expression): Public generic functions
Method, (setf fixtures): Public generic functions
Method, (setf output): Public generic functions
Method, (setf parent): Public generic functions
Method, (setf referenced-dependencies): Public generic functions
Method, (setf referenced-skips): Public generic functions
Method, (setf results): Public generic functions
Method, (setf serial): Public generic functions
Method, (setf show-listing-p): Private generic functions
Method, (setf status): Public generic functions
Method, (setf tests): Public generic functions
Method, (setf time-limit): Public generic functions
Method, (setf value): Public generic functions
Method, (setf value): Public generic functions
Method, (setf value-form): Public generic functions
Method, add-result: Private generic functions
Method, body: Public generic functions
Method, body: Public generic functions
Method, body: Public generic functions
Method, body: Public generic functions
Method, check-evaluatable: Public generic functions
Method, check-evaluatable: Public generic functions
Method, check-evaluatable: Public generic functions
Method, check-evaluatable: Public generic functions
Method, check-evaluatable: Public generic functions
Method, child-status: Public generic functions
Method, children: Public generic functions
Method, children: Public generic functions
Method, comparison: Public generic functions
Method, comparison-geq: Public generic functions
Method, dependencies: Public generic functions
Method, description: Public generic functions
Method, description: Public generic functions
Method, duration: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, eval-in-context: Public generic functions
Method, expected: Public generic functions
Method, expression: Public generic functions
Method, find-child-result: Public generic functions
Method, fixtures: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, format-result: Public generic functions
Method, home: Public generic functions
Method, initialize-instance: Public standalone methods
Method, name: Public generic functions
Method, output: Public generic functions
Method, parent: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, referenced-dependencies: Public generic functions
Method, referenced-skips: Public generic functions
Method, report-on: Public generic functions
Method, report-on: Public generic functions
Method, report-on: Public generic functions
Method, report-on: Public generic functions
Method, result-complete-p: Private generic functions
Method, result-for-testable: Public generic functions
Method, result-for-testable: Public generic functions
Method, results: Public generic functions
Method, results-with-status: Public generic functions
Method, serial: Public generic functions
Method, shared-initialize: Public standalone methods
Method, show-listing-p: Private generic functions
Method, skipped-children: Public generic functions
Method, status: Public generic functions
Method, summarize: Public generic functions
Method, summarize: Public generic functions
Method, summarize: Public generic functions
Method, tests: Public generic functions
Method, tests: Public generic functions
Method, tests-with-status: Public generic functions
Method, time-limit: Public generic functions
Method, value: Public generic functions
Method, value: Public generic functions
Method, value-expected-p: Public generic functions
Method, value-expected-p: Public generic functions
Method, value-form: Public generic functions

N
name: Public generic functions
name: Public generic functions
number-suffix: Private ordinary functions

O
of-type: Public macros
output: Public generic functions
output: Public generic functions

P
package-fixtures: Public ordinary functions
package-tests: Public ordinary functions
parent: Public generic functions
parent: Public generic functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-oneline: Private ordinary functions

R
referenced-dependencies: Public generic functions
referenced-dependencies: Public generic functions
referenced-skips: Public generic functions
referenced-skips: Public generic functions
remove-all-tests-in-package: Public ordinary functions
remove-test: Public ordinary functions
removef: Private ordinary functions
report-on: Public generic functions
report-on: Public generic functions
report-on: Public generic functions
report-on: Public generic functions
report-on: Public generic functions
resolve-dependency-combination: Private ordinary functions
resolve-tests: Private ordinary functions
restore-fixtures: Public ordinary functions
result-complete-p: Private generic functions
result-complete-p: Private generic functions
result-for-testable: Public generic functions
result-for-testable: Public generic functions
result-for-testable: Public generic functions
results: Public generic functions
results: Public generic functions
results-with-status: Public generic functions
results-with-status: Public generic functions
retain: Private ordinary functions

S
serial: Public generic functions
serial: Public generic functions
shared-initialize: Public standalone methods
show-listing-p: Private generic functions
show-listing-p: Private generic functions
shuffle: Private ordinary functions
skip: Public macros
skip-on: Public macros
skipped-children: Public generic functions
skipped-children: Public generic functions
status: Public generic functions
status: Public generic functions
status-character: Public ordinary functions
summarize: Public generic functions
summarize: Public generic functions
summarize: Public generic functions
summarize: Public generic functions

T
test: Public ordinary functions
test-index: Private ordinary functions
test-packages: Public ordinary functions
test-toplevel: Public ordinary functions
tests: Public generic functions
tests: Public generic functions
tests: Public generic functions
tests-with-status: Public generic functions
tests-with-status: Public generic functions
time-limit: Public generic functions
time-limit: Public generic functions
true: Public macros
try-compile: Private ordinary functions

V
value: Public generic functions
value: Public generic functions
value: Public generic functions
value-expected-p: Public generic functions
value-expected-p: Public generic functions
value-expected-p: Public generic functions
value-form: Public generic functions
value-form: Public generic functions

W
with-fixtures: Public macros
with-forced-status: Public macros
with-shuffling: Public macros
with-timeout: Private macros


A.3 Variables

Jump to:   *  
B   C   D   E   F   H   N   O   P   R   S   T   V  
Index Entry  Section

*
*abort-on-timeout-p*: Public special variables
*context*: Public special variables
*fixture-captures*: Public special variables
*fixture-restores*: Public special variables
*level*: Private special variables
*parent*: Public special variables
*real-context*: Private special variables
*silence-plain-compilation-errors-p*: Public special variables
*status-indicators*: Public special variables
*test-indexes*: Private special variables

B
body: Public classes
body: Public classes
body: Public classes
body: Public classes

C
child-status: Public classes
children: Public classes
comparison: Public classes
comparison-geq: Public classes

D
dependencies: Public classes
description: Public classes
description: Public classes
duration: Public classes

E
expected: Public classes
expression: Public classes

F
fixtures: Public classes

H
home: Public classes

N
name: Public classes

O
output: Public classes

P
parent: Public classes

R
results: Public classes

S
serial: Public classes
show-listing-p: Public classes
skipped-children: Public classes
Slot, body: Public classes
Slot, body: Public classes
Slot, body: Public classes
Slot, body: Public classes
Slot, child-status: Public classes
Slot, children: Public classes
Slot, comparison: Public classes
Slot, comparison-geq: Public classes
Slot, dependencies: Public classes
Slot, description: Public classes
Slot, description: Public classes
Slot, duration: Public classes
Slot, expected: Public classes
Slot, expression: Public classes
Slot, fixtures: Public classes
Slot, home: Public classes
Slot, name: Public classes
Slot, output: Public classes
Slot, parent: Public classes
Slot, results: Public classes
Slot, serial: Public classes
Slot, show-listing-p: Public classes
Slot, skipped-children: Public classes
Slot, status: Public classes
Slot, tests: Public classes
Slot, time-limit: Public classes
Slot, value: Public classes
Slot, value: Public classes
Slot, value-form: Public classes
Special Variable, *abort-on-timeout-p*: Public special variables
Special Variable, *context*: Public special variables
Special Variable, *fixture-captures*: Public special variables
Special Variable, *fixture-restores*: Public special variables
Special Variable, *level*: Private special variables
Special Variable, *parent*: Public special variables
Special Variable, *real-context*: Private special variables
Special Variable, *silence-plain-compilation-errors-p*: Public special variables
Special Variable, *status-indicators*: Public special variables
Special Variable, *test-indexes*: Private special variables
status: Public classes

T
tests: Public classes
time-limit: Public classes

V
value: Public classes
value: Public classes
value-form: Public classes


A.4 Data types

Jump to:   C   D   F   G   I   L   M   P   Q   R   S   T   V  
Index Entry  Section

C
Class, comparison-result: Public classes
Class, controlling-result: Public classes
Class, finishing-result: Public classes
Class, group-result: Public classes
Class, interactive: Public classes
Class, largescale: Public classes
Class, multiple-value-comparison-result: Public classes
Class, multiple-value-result: Public classes
Class, parent-result: Public classes
Class, plain: Public classes
Class, quiet: Public classes
Class, report: Public classes
Class, result: Public classes
Class, summary: Public classes
Class, test: Public classes
Class, test-result: Public classes
Class, value-result: Public classes
comparison-result: Public classes
controlling-result: Public classes

D
documentation.lisp: The parachute/documentation․lisp file

F
File, documentation.lisp: The parachute/documentation․lisp file
File, fixture.lisp: The parachute/fixture․lisp file
File, package.lisp: The parachute/package․lisp file
File, parachute.asd: The parachute/parachute․asd file
File, report.lisp: The parachute/report․lisp file
File, result.lisp: The parachute/result․lisp file
File, test.lisp: The parachute/test․lisp file
File, tester.lisp: The parachute/tester․lisp file
File, toolkit.lisp: The parachute/toolkit․lisp file
finishing-result: Public classes
fixture.lisp: The parachute/fixture․lisp file

G
group-result: Public classes

I
interactive: Public classes

L
largescale: Public classes

M
multiple-value-comparison-result: Public classes
multiple-value-result: Public classes

P
Package, parachute: The parachute package
package.lisp: The parachute/package․lisp file
parachute: The parachute system
parachute: The parachute package
parachute.asd: The parachute/parachute․asd file
parent-result: Public classes
plain: Public classes

Q
quiet: Public classes

R
report: Public classes
report.lisp: The parachute/report․lisp file
result: Public classes
result.lisp: The parachute/result․lisp file

S
summary: Public classes
System, parachute: The parachute system

T
test: Public classes
test-result: Public classes
test.lisp: The parachute/test․lisp file
tester.lisp: The parachute/tester․lisp file
timeout: Private types
toolkit.lisp: The parachute/toolkit․lisp file
Type, timeout: Private types

V
value-result: Public classes