The parachute Reference Manual

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

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 Tue Nov 15 06:51:18 2022 GMT+0.

Table of Contents


1 Introduction

About parachute

Parachute is a simple-to-use and extensible testing framework.

How To

In Parachute, things are organised as a bunch of named tests within a package. Each test can contain a bunch of test forms that make up its body. By default true, false, fail, is, isnt, is-values, isnt-values, of-type, and finish are provided as test forms.

(define-test numbers
  (of-type integer 5)
  (true (numberp 2/3))
  (false (numberp :keyword))
  (is-values (values 0 "1")
    (= 0)
    (equal "1")))

The name of a test can be either a symbol or a string, though both get coerced to a string internally.

(define-test "A more descriptive name, perhaps")

Tests can have dependencies in order to ensure that you don't get cascade failures. If a test's dependency fails, it is automatically skipped.

(define-test equality
  :depends-on (numbers)
  (is = 0 1))             ; Bogus

(define-test arithmetic
  :depends-on (equality)
  (is = 5 (+ 2 3)))

Dependencies can also be logically combined if you require more complicated dependency logic.

(define-test unexpected-failure-backup-test
  :depends-on (:and equality (:not arithmetic))
  (of-type number (+ 2 3))) ; Maybe everything broke?

Often times it also makes sense to organise tests according to a hierarchy. For example you could have tests that reflect your type hierarchy, or other kind of structure within your system. You can also use this to create simple test suites.

(define-test suite)

(define-test test-a
  :parent suite
  #|...|#)

(define-test (suite test-b)
  #|...|#)

(define-test other-suite
  #|...|#
  (define-test other-test
     #|...|#))

Sometimes it is then useful to skip children if you know that they are either faulty or incomplete and shouldn't yet be tested as part of the greater scheme.

(define-test suite
  :skip (test-a))

If you need to skip individual test forms rather than a whole test, you can use the skip form.

(define-test stuff
  (true :pass)
  (skip "Not ready yet"
    (is = 5 (some-unimplemented-function 10))))

If you need to skip tests depending on the implementation, or the presence of other feature combinations, you can use skip-on.

(define-test stuff
  (skip-on (clisp) "Not supported on clisp."
    (is equal #p"a/b/" (merge-pathnames "b/" "a/"))))

In order to ensure that there is no accidental sequential dependency between test forms or children, you can use the :serial NIL option, which will shuffle the test forms and children each time before evaluating them.

(define-test random
  :serial NIL
  (true 1)
  (true 2)
  (true 3)
  (true 4)
  (true 5))

If you need to wrap your test forms in some kind of environment, then the shuffling won't work automatically. However, you can fix this by wrapping the forms in a with-shuffling form.

(define-test random-2
  (let ((a 0))
    (with-shuffling
      (is = 1 (incf a))
      (is = 2 (incf a))
      (is = 3 (incf a)))))

In case your code will cause changes to the global environment, you probably will want to fix it in place to make sure they are restored to their former values after the test completes. Parachute allows you to automatically fix variables, functions, and macros in place.

(define-test float-format
  :fix (*read-default-float-format*)
  (of-type single-float (read-from-string "0.5"))
  (setf *read-default-float-format* 'double-float)
  (of-type double-float (read-from-string "0.5")))

You can also tell it to hold all the symbols accessible to a certain package in place by specifying a package designator as a keyword, gensym, or string. In any case, note that these fixtures only apply to the test itself, not to any child tests that might be associated.

Using with-fixtures, fixing can also be done locally. It expects an evaluated list of bindings to fix in place.

(define-test float-format2
  (with-fixtures '(*read-default-float-format*)
    (setf *read-default-float-format* 'double-float)
    (of-type double-float (read-from-string "0.5")))
  (of-type single-float (read-from-string "0.5")))

If you have a user-defined binding to a symbol you can also make the fixture system aware of it so that it'll capture the bindings automatically.

(define-fixture-capture my-binding (symbol)
  (when (my-binding-bound-p symbol)
    (values (my-binding-value symbol) T)))

(define-fixture-restore my-binding (symbol value)
  (setf (my-binding-value symbol) value))

Sometimes the compiler will already complain for some tests that you expect to fail, for instance when the type inference is too good. In that case you can force Parachute to only compile the test forms when the test is evaluated. This is also useful when you're continuously working on macros and the like and don't want to recompile the test all the time. Parachute does not do this by default in order to give you useful compiler feedback in case you mess up writing your tests, and in order to avoid having to pay the time to invoke the compiler when it usually isn't necessary. Note that the compilation of the forms will be factored into your timing results.

(define-test compare-numbers
  :compile-at :execute
  (fail (= :5 5)))

Finally, Parachute also allows you to enforce timing constraints on tests to make sure that they complete within a specified limit.

(define-test too-slow
  :time-limit 0.5
  (sleep 1))

Tests are run under a report context, which gathers a bunch of result objects that are generated as part of the evaluation and is responsible for presenting them to the user in some hopefully useful manner. The standard report is plain, which reports things as text to the REPL.

(test 'arithmetic)

plain-test-result

There are two more report types included in the standard distribution, namely quiet and interactive. The former should not produce any output or user-interaction whatseover.

(test 'arithmethic :report 'quiet)

quiet-test-result

The latter on the other hand will present you the debugger with a handful of useful restarts whenever a test fails. This allows you to iteratively and dynamically develop and refine tests.

(test 'arithmetic :report 'interactive)

interactive-test-result

And that should cover most of it. Parachute does not have any fancy ASDF integration, however I don't believe any is needed anyway. Simply modifying your main system and test system as follows should be sufficient.

(asdf:defsystem main-system
  #|...|#
  :in-order-to ((asdf:test-op (asdf:test-op :test-system))))

(asdf:defsystem test-system
  #|...|#
  :perform (asdf:test-op (op c) (uiop:symbol-call :parachute :test :test-package)))

This should allow you to run the tests via ASDF like so: (asdf:test-system :main-system). If you are integrating with a remote CI and would like asdf:test-system to quit with a useful exit code for Parachute systems, set cl-user::*exit-on-test-failures* to T. This'll cause any invocation of test to behave like test-toplevel.

Compatibility Layers

Parachute offers "zero-cost switching" by implementing basic compatibility layers that simulate another test framework's syntax and behaviour. This allows you to switch over from another test framework hopefully without having to change a single test in your suite.

Usually the only thing you need to do to get this done is change the name of the framework in your test system dependencies to one prefixed with parachute-. However, since there's so many test frameworks, and each layer requires quite a bit of work and investigation, only some are supported.

The layers only mirror the public API of the test frameworks and leave out any extension mechanisms. They also do not attempt to mirror the output format or interaction method by which the other frameworks functioned, as there would be little point to mirroring them exactly.

Compatibility layers exist for:

Extending Parachute

Test and Result Evaluation

Parachute follows its own evaluation semantics in order to run tests. Primarily this means that most everything goes through one central function called eval-in-context. This functions allows you to customise evaluation based on both what the context is, and what the object being "evaluated" is.

Usually the context is a report object, but other situations might also be conceived. Either way, it is your responsibility to add methods to this function when you add a new result type, some kind of test subclass, or a new report type that you want to customise according to your desired behaviour.

The evaluation of results is decoupled from the context and reports in the sense that their behaviour does not, by default, depend on it. At the most basic, the result class defines a single :around method that takes care of recording the duration of the test evaluation, setting a default status after finishing without errors, and skipping evaluation if the status is already set to something other than :unknown.

Next we have a result object that is interesting for anything that actually produces direct test results-- value-result. Upon evaluation, if the value slot is not yet bound, it calls its body function and stores the return value thereof in the value slot.

However, the result type that is actually used for all standard test forms is the comparison-result. This also takes a comparator function and an expected result to compare against upon completion of the test. If the results match, then the test status is set to :passed, otherwise to :failed.

Since Parachute allows for a hierarchy in your tests, there have to be aggregate results as well, and indeed there are. Two of them, actually. First is the base case, namely parent-result which does two things on evaluation: one, it binds *parent* to itself to allow other results to register themselves upon construction, and two it sets its status to :failed if any of the children have failed.

Finally we have the test-result which takes care of properly evaluating an actual test object. What this means is to evaluate all dependencies before anything else happens, and to check the time limit after everything else has happened. If the time limit has exceeded, set the description accordingly and mark the result as :failed. For its main eval-in-context method however it checks whether any of the dependencies have failed, and if so, mark itself as :skipped. Otherwise it calls eval-in-context on the actual test object.

The default evaluation procedure for a test itself is to simply call all the functions in the tests list in a with-fixtures environment.

And that describes the semantics of default test procedures. Actual test forms like is are created through macros that emit an (eval-in-context *context* (make-instance 'comparison-result #|...|#)) form. The *context* object is automatically bound to the context object on call of eval-in-context and thus always refers to the current context object. This allows results to be evaluated even from within opaque parts like user-defined functions.

Report Generation

Finally we come to the question of how to generate a report and interact with the evaluation process. The most primitive idea for a report is one that doesn't do anything at all, except for perhaps catching stray errors. This is implemented by the quiet report object, which only has a single eval-in-context :around method that has a handler-case around the rest.

It should be possible to get any kind of reporting behaviour you want by adding methods that specialise on your report object to eval-in-context. For the simple case where you want something that prints to the REPL but has a different style than the preset plain report, you can simply subclass that and specialise on the report-on and summarize functions that then produce the output you want.

Since you can control pretty much every aspect of evaluation rather closely, very different behaviours and recovery mechanisms are also possible to achieve. One final aspect to note is result-for-testable, which should return an appropriate result object for the given testable. This should only return fresh result objects if no result is already known for the testable in the given context. The standard tests provide for this, however they only ever return a standard test-result instance. If you need to customise the behaviour of the evaluation for that part, it would be a wise idea to subclass test-result and make sure to return instances thereof from result-for-testable for your report.

Finally it should be noted that if you happen to create new result types that you might want to run using the default reports, you should add methods to format-result that specialise on the keywords :oneline and :extensive for the type. These should return a string containing an appropriate description of the test in one line or extensively, respectively. This will allow you to customise how things look to some degree without having to create a new report object entirely.


2 Systems

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


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

2.1 parachute

An extensible and cross-compatible testing framework.

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

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.


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

3.1 Lisp


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

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

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

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.


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

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.


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

5.1 Public Interface


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

5.1.1 Special variables

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.


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: 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.

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 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 ((report report) stream)
Source

report.lisp.

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

test.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: 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 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


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

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: *silence-plain-compilation-errors-p*

Whether PLAIN report should silence errors.

See DEFINE-TEST+RUN

Package

parachute.

Source

test.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.


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

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 is a list that has one of the following symbols as its first element:
- QUOTE
- LAMBDA
- FUNCTION
- SB-INT:QUASIQUOTE
- SI:QUASIQUOTE
- 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 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.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   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
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, 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-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
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, 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-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, 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-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
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

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

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

A.3 Variables

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

*
*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*: Private 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, *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*: Private 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

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

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

A.4 Data types

Jump to:   C   D   F   G   I   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, 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

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
toolkit.lisp: The parachute/toolkit․lisp file

V
value-result: Public classes

Jump to:   C   D   F   G   I   M   P   Q   R   S   T   V