The parachute Reference Manual

Table of Contents

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

The parachute Reference Manual

This is the parachute Reference Manual, version 1.1.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:22:09 2018 GMT+0.


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

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

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 giving it a package designator as a keyword, gensym, or string. Using with-fixtures, this can also be done locally. It expects an evaluated list of fixtures.

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

This should allow you to run the tests via ASDF like so: (asdf:test-system :main-system).

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. Finally it evaluates every one of the children of the test, making sure to mark the ones in the skipped-children list as :skipped beforehand.

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.


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

2 Systems

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


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

2.1 parachute

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/parachute

License

Artistic

Description

An extensible and cross-compatible testing framework.

Version

1.1.0

Dependencies
Source

parachute.asd (file)

Components

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

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

3.1.1 parachute.asd

Location

parachute.asd

Systems

parachute (system)


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

3.1.2 parachute/package.lisp

Parent

parachute (system)

Location

package.lisp

Packages

parachute


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

3.1.3 parachute/toolkit.lisp

Dependency

package.lisp (file)

Parent

parachute (system)

Location

toolkit.lisp

Exported Definitions

with-shuffling (macro)

Internal Definitions

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

3.1.4 parachute/fixture.lisp

Dependency

toolkit.lisp (file)

Parent

parachute (system)

Location

fixture.lisp

Exported Definitions

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

3.1.5 parachute/test.lisp

Dependency

fixture.lisp (file)

Parent

parachute (system)

Location

test.lisp

Exported Definitions
Internal Definitions

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

3.1.6 parachute/result.lisp

Dependency

test.lisp (file)

Parent

parachute (system)

Location

result.lisp

Exported Definitions
Internal Definitions

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

3.1.7 parachute/tester.lisp

Dependency

result.lisp (file)

Parent

parachute (system)

Location

tester.lisp

Exported Definitions
Internal Definitions

destructure-is-values-body (function)


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

3.1.8 parachute/report.lisp

Dependency

tester.lisp (file)

Parent

parachute (system)

Location

report.lisp

Exported Definitions
Internal Definitions

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

3.1.9 parachute/example.lisp

Dependency

report.lisp (file)

Parent

parachute (system)

Location

example.lisp


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

3.1.10 parachute/documentation.lisp

Dependency

example.lisp (file)

Parent

parachute (system)

Location

documentation.lisp


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

4 Packages

Packages are listed by definition order.


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

4.1 parachute

Source

package.lisp (file)

Nickname

org.shirakumo.parachute

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [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 (file)

Special Variable: *fixture-captures*

A map of names to fixture capture functions.

See DEFINE-FIXTURE-CAPTURE

Package

parachute

Source

fixture.lisp (file)

Special Variable: *fixture-restores*

A map of names to fixture restore functions.

See DEFINE-FIXTURE-RESTORE

Package

parachute

Source

fixture.lisp (file)

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


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

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

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

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.

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.

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

Package

parachute

Source

test.lisp (file)

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

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

Macro: finish FORM &optional DESCRIPTION &rest FORMAT-ARGS

A tester that succeeds if the form returns without escaping.

Package

parachute

Source

tester.lisp (file)

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

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

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

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

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

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

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

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

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

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


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

5.1.3 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 (file)

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

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

Writer

(setf find-test) (function)

Function: (setf find-test) TEST-INSTANCE NAME &optional PACKAGE-ISH
Package

parachute

Source

test.lisp (file)

Reader

find-test (function)

Function: package-fixtures NAME

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

Package

parachute

Source

fixture.lisp (file)

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

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

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

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


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

5.1.4 Generic functions

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

Writer

(setf children) (generic function)

Methods
Method: children (TEST test) around
Source

test.lisp (file)

Method: children (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

children (generic function)

Methods
Method: (setf children) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: comparison OBJECT

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

See COMPARISON-RESULT

Package

parachute

Writer

(setf comparison) (generic function)

Methods
Method: comparison (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated reader method

Source

result.lisp (file)

Method: comparison (COMPARISON-RESULT comparison-result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

comparison (generic function)

Methods
Method: (setf comparison) NEW-VALUE (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf comparison) NEW-VALUE (COMPARISON-RESULT comparison-result)

automatically generated writer method

Source

result.lisp (file)

Generic Function: comparison-geq OBJECT

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

Defaults to T.

See COMPARISON-RESULT
See GEQ

Package

parachute

Writer

(setf comparison-geq) (generic function)

Methods
Method: comparison-geq (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated reader method

Source

result.lisp (file)

Method: comparison-geq (COMPARISON-RESULT comparison-result)

automatically generated reader method

Source

result.lisp (file)

Generic Function: (setf comparison-geq) NEW-VALUE OBJECT
Package

parachute

Reader

comparison-geq (generic function)

Methods
Method: (setf comparison-geq) NEW-VALUE (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf comparison-geq) NEW-VALUE (COMPARISON-RESULT comparison-result)

automatically generated writer method

Source

result.lisp (file)

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

Generic Function: description OBJECT

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

See RESULT
See TEST

Package

parachute

Writer

(setf description) (generic function)

Methods
Method: description (RESULT result)

automatically generated reader method

Source

result.lisp (file)

Method: description (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

description (generic function)

Methods
Method: (setf description) NEW-VALUE (RESULT result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf description) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: 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

Writer

(setf duration) (generic function)

Methods
Method: duration (RESULT result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

duration (generic function)

Methods
Method: (setf duration) NEW-VALUE (RESULT result)

automatically generated writer method

Source

result.lisp (file)

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

Package

parachute

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

report.lisp (file)

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

report.lisp (file)

Method: eval-in-context (REPORT plain) (RESULT result)
Source

report.lisp (file)

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

report.lisp (file)

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

report.lisp (file)

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

report.lisp (file)

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

report.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

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

result.lisp (file)

Method: eval-in-context CONTEXT THING around
Source

result.lisp (file)

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

test.lisp (file)

Generic Function: expected OBJECT

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

See COMPARISON-RESULT

Package

parachute

Writer

(setf expected) (generic function)

Methods
Method: expected (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated reader method

Source

result.lisp (file)

Method: expected (COMPARISON-RESULT comparison-result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

expected (generic function)

Methods
Method: (setf expected) NEW-VALUE (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf expected) NEW-VALUE (COMPARISON-RESULT comparison-result)

automatically generated writer method

Source

result.lisp (file)

Generic Function: expression OBJECT

The expression that the result object is about.

See RESULT

Package

parachute

Writer

(setf expression) (generic function)

Methods
Method: expression (RESULT result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

expression (generic function)

Methods
Method: (setf expression) NEW-VALUE (RESULT result)

automatically generated writer method

Source

result.lisp (file)

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

Generic Function: fixtures OBJECT

The list of fixed symbols or packages.

See WITH-FIXTURE
See TEST

Package

parachute

Writer

(setf fixtures) (generic function)

Methods
Method: fixtures (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

fixtures (generic function)

Methods
Method: (setf fixtures) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

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

Method: format-result (RESULT test-result) (TYPE (eql extensive))
Source

result.lisp (file)

Method: format-result (RESULT test-result) (TYPE (eql oneline))
Source

result.lisp (file)

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

result.lisp (file)

Method: format-result (RESULT comparison-result) (TYPE (eql extensive))
Source

result.lisp (file)

Method: format-result (RESULT finishing-result) (TYPE (eql extensive))
Source

result.lisp (file)

Method: format-result (RESULT result) (TYPE (eql extensive))
Source

result.lisp (file)

Method: format-result (RESULT result) (TYPE (eql oneline))
Source

result.lisp (file)

Generic Function: home OBJECT

The home package of the test.

See TEST

Package

parachute

Methods
Method: home (TEST test)

automatically generated reader method

Source

test.lisp (file)

Generic Function: name OBJECT

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

See TEST

Package

parachute

Methods
Method: name (TEST test)

automatically generated reader method

Source

test.lisp (file)

Generic Function: output OBJECT

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

See PLAIN
See REPORT-ON
See SUMMARIZE

Package

parachute

Writer

(setf output) (generic function)

Methods
Method: output (PLAIN plain)

automatically generated reader method

Source

report.lisp (file)

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

parachute

Reader

output (generic function)

Methods
Method: (setf output) NEW-VALUE (PLAIN plain)

automatically generated writer method

Source

report.lisp (file)

Generic Function: 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

Writer

(setf parent) (generic function)

Methods
Method: parent (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

parent (generic function)

Methods
Method: (setf parent) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: 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

Writer

(setf referenced-dependencies) (generic function)

Methods
Method: referenced-dependencies (TEST test)

automatically generated reader method

Source

test.lisp (file)

Generic Function: (setf referenced-dependencies) NEW-VALUE OBJECT
Package

parachute

Reader

referenced-dependencies (generic function)

Methods
Method: (setf referenced-dependencies) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: referenced-skips OBJECT

The list of test designators that reference a skipped test.

See SKIPPED-CHILDREN
See TEST

Package

parachute

Writer

(setf referenced-skips) (generic function)

Methods
Method: referenced-skips (TEST test)

automatically generated reader method

Source

test.lisp (file)

Generic Function: (setf referenced-skips) NEW-VALUE OBJECT
Package

parachute

Reader

referenced-skips (generic function)

Methods
Method: (setf referenced-skips) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: report-on RESULT 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 (file)

Method: report-on THING (REPORT plain) after
Source

report.lisp (file)

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

report.lisp (file)

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

Method: result-for-testable (TEST test) CONTEXT
Source

result.lisp (file)

Generic Function: results OBJECT

The vector of child results within the parent.

See PARENT-RESULT
See ADD-CHILD

Package

parachute

Writer

(setf results) (generic function)

Methods
Method: results (PARENT-RESULT parent-result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

results (generic function)

Methods
Method: (setf results) NEW-VALUE (PARENT-RESULT parent-result)

automatically generated writer method

Source

result.lisp (file)

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

Generic Function: 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

Writer

(setf serial) (generic function)

Methods
Method: serial (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

serial (generic function)

Methods
Method: (setf serial) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

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

Generic Function: 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

Writer

(setf status) (generic function)

Methods
Method: status (RESULT result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

status (generic function)

Methods
Method: (setf status) NEW-VALUE (RESULT result)

automatically generated writer method

Source

result.lisp (file)

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

Method: summarize (REPORT report)
Source

report.lisp (file)

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

Writer

(setf tests) (generic function)

Methods
Method: tests (TEST test) around
Source

test.lisp (file)

Method: tests (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

tests (generic function)

Methods
Method: (setf tests) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

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

Generic Function: 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

Writer

(setf time-limit) (generic function)

Methods
Method: time-limit (TEST test)

automatically generated reader method

Source

test.lisp (file)

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

parachute

Reader

time-limit (generic function)

Methods
Method: (setf time-limit) NEW-VALUE (TEST test)

automatically generated writer method

Source

test.lisp (file)

Generic Function: value OBJECT

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

See BODY
See VALUE-RESULT

Package

parachute

Writer

(setf value) (generic function)

Methods
Method: value (MULTIPLE-VALUE-RESULT multiple-value-result)

automatically generated reader method

Source

result.lisp (file)

Method: value (VALUE-RESULT value-result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

value (generic function)

Methods
Method: (setf value) NEW-VALUE (MULTIPLE-VALUE-RESULT multiple-value-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf value) NEW-VALUE (VALUE-RESULT value-result)

automatically generated writer method

Source

result.lisp (file)

Generic Function: value-form OBJECT

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

See COMPARISON-RESULT

Package

parachute

Writer

(setf value-form) (generic function)

Methods
Method: value-form (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated reader method

Source

result.lisp (file)

Method: value-form (COMPARISON-RESULT comparison-result)

automatically generated reader method

Source

result.lisp (file)

Generic Function: (setf value-form) NEW-VALUE OBJECT
Package

parachute

Reader

value-form (generic function)

Methods
Method: (setf value-form) NEW-VALUE (MULTIPLE-VALUE-COMPARISON-RESULT multiple-value-comparison-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf value-form) NEW-VALUE (COMPARISON-RESULT comparison-result)

automatically generated writer method

Source

result.lisp (file)


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

5.1.5 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

Package

parachute

Source

result.lisp (file)

Direct superclasses

value-result (class)

Direct methods
Direct slots
Slot: value-form
Initargs

:value-form

Readers

value-form (generic function)

Writers

(setf value-form) (generic function)

Slot: expected
Initargs

:expected

Readers

expected (generic function)

Writers

(setf expected) (generic function)

Slot: comparison
Initargs

:comparison

Readers

comparison (generic function)

Writers

(setf comparison) (generic function)

Slot: comparison-geq
Initargs

:comparison-geq

Readers

comparison-geq (generic function)

Writers

(setf comparison-geq) (generic function)

Direct Default Initargs
InitargValue
:value-form:unknown
:expected(quote (not null))
:comparison(quote typep)
:comparison-geqt
Class: finishing-result ()

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

See VALUE-RESULT

Package

parachute

Source

result.lisp (file)

Direct superclasses

value-result (class)

Direct methods
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 (file)

Direct superclasses

report (class)

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 VALUE-RESULT

Package

parachute

Source

result.lisp (file)

Direct superclasses

multiple-value-result (class)

Direct methods
Direct slots
Slot: value-form
Initargs

:value-form

Readers

value-form (generic function)

Writers

(setf value-form) (generic function)

Slot: expected
Initargs

:expected

Readers

expected (generic function)

Writers

(setf expected) (generic function)

Slot: comparison
Initargs

:comparison

Readers

comparison (generic function)

Writers

(setf comparison) (generic function)

Slot: comparison-geq
Initargs

:comparison-geq

Readers

comparison-geq (generic function)

Writers

(setf comparison-geq) (generic function)

Direct Default Initargs
InitargValue
:value-form:unknown
:expected(quote ((not null)))
:comparison(quote (typep))
:comparison-geqt
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 (file)

Direct superclasses

value-result (class)

Direct subclasses

multiple-value-comparison-result (class)

Direct methods
Direct slots
Slot: value
Initargs

:value

Readers

value (generic function)

Writers

(setf value) (generic function)

Slot: body
Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)

Direct Default Initargs
InitargValue
:body(error "body required.")
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 (file)

Direct superclasses

result (class)

Direct subclasses
Direct methods
Direct slots
Slot: results
Initform

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

Readers

results (generic function)

Writers

(setf results) (generic function)

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

Direct superclasses

report (class)

Direct methods
Direct slots
Slot: output
Initargs

:stream, :output

Readers

output (generic function)

Writers

(setf output) (generic function)

Direct Default Initargs
InitargValue
:streamt
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 (file)

Direct superclasses

report (class)

Direct methods

eval-in-context (method)

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

Direct superclasses

parent-result (class)

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

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: expression
Initargs

:expression

Readers

expression (generic function)

Writers

(setf expression) (generic function)

Slot: status
Initargs

:status

Readers

status (generic function)

Writers

(setf status) (generic function)

Slot: duration
Initargs

:duration

Readers

duration (generic function)

Writers

(setf duration) (generic function)

Slot: description
Initargs

:description

Readers

description (generic function)

Writers

(setf description) (generic function)

Direct Default Initargs
InitargValue
:expression(error "expression required.")
:status:unknown
:durationnil
:descriptionnil
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.

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

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

name (generic function)

Slot: home
Initargs

:home

Readers

home (generic function)

Slot: description
Initargs

:description

Readers

description (generic function)

Writers

(setf description) (generic function)

Slot: parent
Initargs

:parent

Readers

parent (generic function)

Writers

(setf parent) (generic function)

Slot: children
Readers

children (generic function)

Writers

(setf children) (generic function)

Slot: dependencies
Initargs

:dependencies, :depends-on

Readers

referenced-dependencies (generic function)

Writers

(setf referenced-dependencies) (generic function)

Slot: fixtures
Initargs

:fixtures, :fix

Readers

fixtures (generic function)

Writers

(setf fixtures) (generic function)

Slot: time-limit
Initargs

:time-limit

Readers

time-limit (generic function)

Writers

(setf time-limit) (generic function)

Slot: skipped-children
Initargs

:skipped-children, :skip

Readers

referenced-skips (generic function)

Writers

(setf referenced-skips) (generic function)

Slot: tests
Initargs

:tests

Readers

tests (generic function)

Writers

(setf tests) (generic function)

Slot: serial
Initargs

:serial

Readers

serial (generic function)

Writers

(setf serial) (generic function)

Direct Default Initargs
InitargValue
:name(error "name required.")
:home*package*
:descriptionnil
:parentnil
:dependenciesnil
:fixturesnil
:time-limitnil
:skipped-childrennil
:serialt
:testsnil
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 (file)

Direct superclasses

parent-result (class)

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

Direct superclasses

result (class)

Direct subclasses
Direct methods
Direct slots
Slot: value
Initargs

:value

Readers

value (generic function)

Writers

(setf value) (generic function)

Slot: body
Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)

Direct Default Initargs
InitargValue
:body(error "body required.")

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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *level*
Package

parachute

Source

report.lisp (file)

Special Variable: *real-context*

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

See CONTROLLING-RESULT

Package

parachute

Source

result.lisp (file)

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


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

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

Macro: lformat FORMAT &rest ARGS
Package

parachute

Source

report.lisp (file)


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

5.2.3 Functions

Function: call-compile FORM

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

Package

parachute

Source

toolkit.lisp (file)

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

Function: destructure-is-values-body BODY
Package

parachute

Source

tester.lisp (file)

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

Function: filter-test-results RESULTS
Package

parachute

Source

report.lisp (file)

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

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

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

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

Function: number-suffix N
Package

parachute

Source

toolkit.lisp (file)

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

Function: removef PLACE &rest INDICATORS

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

Package

parachute

Source

toolkit.lisp (file)

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

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

Function: shuffle SEQ

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

Package

parachute

Source

toolkit.lisp (file)

Function: test-index NAME PACKAGE-ISH

Returns the map for names to test instances.

See FIND-TEST

Package

parachute

Source

test.lisp (file)


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

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

Generic Function: body OBJECT

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

See VALUE
See VALUE-RESULT

Package

parachute

Writer

(setf body) (generic function)

Methods
Method: body (CONTROLLING-RESULT controlling-result)

automatically generated reader method

Source

result.lisp (file)

Method: body (MULTIPLE-VALUE-RESULT multiple-value-result)

automatically generated reader method

Source

result.lisp (file)

Method: body (VALUE-RESULT value-result)

automatically generated reader method

Source

result.lisp (file)

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

parachute

Reader

body (generic function)

Methods
Method: (setf body) NEW-VALUE (CONTROLLING-RESULT controlling-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf body) NEW-VALUE (MULTIPLE-VALUE-RESULT multiple-value-result)

automatically generated writer method

Source

result.lisp (file)

Method: (setf body) NEW-VALUE (VALUE-RESULT value-result)

automatically generated writer method

Source

result.lisp (file)

Generic Function: child-status OBJECT

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

See CONTROLLING-RESULT

Package

parachute

Writer

(setf child-status) (generic function)

Methods
Method: child-status (CONTROLLING-RESULT controlling-result)

automatically generated reader method

Source

result.lisp (file)

Generic Function: (setf child-status) NEW-VALUE OBJECT
Package

parachute

Reader

child-status (generic function)

Methods
Method: (setf child-status) NEW-VALUE (CONTROLLING-RESULT controlling-result)

automatically generated writer method

Source

result.lisp (file)


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

5.2.5 Classes

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

Direct superclasses

parent-result (class)

Direct methods
Direct slots
Slot: child-status
Initargs

:child-status

Readers

child-status (generic function)

Writers

(setf child-status) (generic function)

Slot: body
Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   F   L   P  
Index Entry  Section

F
File, Lisp, parachute.asd: The parachute<dot>asd file
File, Lisp, parachute/documentation.lisp: The parachute/documentation<dot>lisp file
File, Lisp, parachute/example.lisp: The parachute/example<dot>lisp file
File, Lisp, parachute/fixture.lisp: The parachute/fixture<dot>lisp file
File, Lisp, parachute/package.lisp: The parachute/package<dot>lisp file
File, Lisp, parachute/report.lisp: The parachute/report<dot>lisp file
File, Lisp, parachute/result.lisp: The parachute/result<dot>lisp file
File, Lisp, parachute/test.lisp: The parachute/test<dot>lisp file
File, Lisp, parachute/tester.lisp: The parachute/tester<dot>lisp file
File, Lisp, parachute/toolkit.lisp: The parachute/toolkit<dot>lisp file

L
Lisp File, parachute.asd: The parachute<dot>asd file
Lisp File, parachute/documentation.lisp: The parachute/documentation<dot>lisp file
Lisp File, parachute/example.lisp: The parachute/example<dot>lisp file
Lisp File, parachute/fixture.lisp: The parachute/fixture<dot>lisp file
Lisp File, parachute/package.lisp: The parachute/package<dot>lisp file
Lisp File, parachute/report.lisp: The parachute/report<dot>lisp file
Lisp File, parachute/result.lisp: The parachute/result<dot>lisp file
Lisp File, parachute/test.lisp: The parachute/test<dot>lisp file
Lisp File, parachute/tester.lisp: The parachute/tester<dot>lisp file
Lisp File, parachute/toolkit.lisp: The parachute/toolkit<dot>lisp file

P
parachute.asd: The parachute<dot>asd file
parachute/documentation.lisp: The parachute/documentation<dot>lisp file
parachute/example.lisp: The parachute/example<dot>lisp file
parachute/fixture.lisp: The parachute/fixture<dot>lisp file
parachute/package.lisp: The parachute/package<dot>lisp file
parachute/report.lisp: The parachute/report<dot>lisp file
parachute/result.lisp: The parachute/result<dot>lisp file
parachute/test.lisp: The parachute/test<dot>lisp file
parachute/tester.lisp: The parachute/tester<dot>lisp file
parachute/toolkit.lisp: The parachute/toolkit<dot>lisp file

Jump to:   F   L   P  

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): Internal generic functions
(setf body): Internal generic functions
(setf body): Internal generic functions
(setf body): Internal generic functions
(setf child-status): Internal generic functions
(setf child-status): Internal generic functions
(setf children): Exported generic functions
(setf children): Exported generic functions
(setf comparison): Exported generic functions
(setf comparison): Exported generic functions
(setf comparison): Exported generic functions
(setf comparison-geq): Exported generic functions
(setf comparison-geq): Exported generic functions
(setf comparison-geq): Exported generic functions
(setf description): Exported generic functions
(setf description): Exported generic functions
(setf description): Exported generic functions
(setf duration): Exported generic functions
(setf duration): Exported generic functions
(setf expected): Exported generic functions
(setf expected): Exported generic functions
(setf expected): Exported generic functions
(setf expression): Exported generic functions
(setf expression): Exported generic functions
(setf find-test): Exported functions
(setf fixtures): Exported generic functions
(setf fixtures): Exported generic functions
(setf output): Exported generic functions
(setf output): Exported generic functions
(setf parent): Exported generic functions
(setf parent): Exported generic functions
(setf referenced-dependencies): Exported generic functions
(setf referenced-dependencies): Exported generic functions
(setf referenced-skips): Exported generic functions
(setf referenced-skips): Exported generic functions
(setf results): Exported generic functions
(setf results): Exported generic functions
(setf serial): Exported generic functions
(setf serial): Exported generic functions
(setf status): Exported generic functions
(setf status): Exported generic functions
(setf tests): Exported generic functions
(setf tests): Exported generic functions
(setf time-limit): Exported generic functions
(setf time-limit): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf value): Exported generic functions
(setf value-form): Exported generic functions
(setf value-form): Exported generic functions
(setf value-form): Exported generic functions

A
add-result: Internal generic functions
add-result: Internal generic functions

B
body: Internal generic functions
body: Internal generic functions
body: Internal generic functions
body: Internal generic functions

C
call-compile: Internal functions
call-with-fixtures: Exported functions
capture-error: Internal macros
capture-fixtures: Exported functions
check-dependency-combination: Internal functions
child-status: Internal generic functions
child-status: Internal generic functions
children: Exported generic functions
children: Exported generic functions
children: Exported generic functions
comparison: Exported generic functions
comparison: Exported generic functions
comparison: Exported generic functions
comparison-geq: Exported generic functions
comparison-geq: Exported generic functions
comparison-geq: Exported generic functions

D
define-fixture-capture: Exported macros
define-fixture-restore: Exported macros
define-test: Exported macros
dependencies: Exported generic functions
dependencies: Exported generic functions
description: Exported generic functions
description: Exported generic functions
description: Exported generic functions
destructure-is-values-body: Internal functions
duration: Exported generic functions
duration: Exported generic functions

E
eval-dependency-combination: Internal functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
eval-in-context: Exported generic functions
expected: Exported generic functions
expected: Exported generic functions
expected: Exported generic functions
expression: Exported generic functions
expression: Exported generic functions

F
fail: Exported macros
false: Exported macros
filter-test-results: Internal functions
find-child-result: Exported generic functions
find-child-result: Exported generic functions
find-test: Exported functions
finish: Exported macros
fixtures: Exported generic functions
fixtures: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
format-result: Exported generic functions
Function, (setf find-test): Exported functions
Function, call-compile: Internal functions
Function, call-with-fixtures: Exported functions
Function, capture-fixtures: Exported functions
Function, check-dependency-combination: Internal functions
Function, destructure-is-values-body: Internal functions
Function, eval-dependency-combination: Internal functions
Function, filter-test-results: Internal functions
Function, find-test: Exported functions
Function, geq: Internal functions
Function, locked-package-p: Internal functions
Function, maybe-quote: Internal functions
Function, maybe-unquote: Internal functions
Function, number-suffix: Internal functions
Function, package-fixtures: Exported functions
Function, package-tests: Exported functions
Function, print-oneline: Internal functions
Function, remove-test: Exported functions
Function, removef: Internal functions
Function, resolve-dependency-combination: Internal functions
Function, resolve-tests: Internal functions
Function, restore-fixtures: Exported functions
Function, shuffle: Internal functions
Function, test: Exported functions
Function, test-index: Internal functions

G
Generic Function, (setf body): Internal generic functions
Generic Function, (setf child-status): Internal generic functions
Generic Function, (setf children): Exported generic functions
Generic Function, (setf comparison): Exported generic functions
Generic Function, (setf comparison-geq): Exported generic functions
Generic Function, (setf description): Exported generic functions
Generic Function, (setf duration): Exported generic functions
Generic Function, (setf expected): Exported generic functions
Generic Function, (setf expression): Exported generic functions
Generic Function, (setf fixtures): Exported generic functions
Generic Function, (setf output): Exported generic functions
Generic Function, (setf parent): Exported generic functions
Generic Function, (setf referenced-dependencies): Exported generic functions
Generic Function, (setf referenced-skips): Exported generic functions
Generic Function, (setf results): Exported generic functions
Generic Function, (setf serial): Exported generic functions
Generic Function, (setf status): Exported generic functions
Generic Function, (setf tests): Exported generic functions
Generic Function, (setf time-limit): Exported generic functions
Generic Function, (setf value): Exported generic functions
Generic Function, (setf value-form): Exported generic functions
Generic Function, add-result: Internal generic functions
Generic Function, body: Internal generic functions
Generic Function, child-status: Internal generic functions
Generic Function, children: Exported generic functions
Generic Function, comparison: Exported generic functions
Generic Function, comparison-geq: Exported generic functions
Generic Function, dependencies: Exported generic functions
Generic Function, description: Exported generic functions
Generic Function, duration: Exported generic functions
Generic Function, eval-in-context: Exported generic functions
Generic Function, expected: Exported generic functions
Generic Function, expression: Exported generic functions
Generic Function, find-child-result: Exported generic functions
Generic Function, fixtures: Exported generic functions
Generic Function, format-result: Exported generic functions
Generic Function, home: Exported generic functions
Generic Function, name: Exported generic functions
Generic Function, output: Exported generic functions
Generic Function, parent: Exported generic functions
Generic Function, referenced-dependencies: Exported generic functions
Generic Function, referenced-skips: Exported generic functions
Generic Function, report-on: Exported generic functions
Generic Function, result-for-testable: Exported generic functions
Generic Function, results: Exported generic functions
Generic Function, results-with-status: Exported generic functions
Generic Function, serial: Exported generic functions
Generic Function, skipped-children: Exported generic functions
Generic Function, status: Exported generic functions
Generic Function, summarize: Exported generic functions
Generic Function, tests: Exported generic functions
Generic Function, tests-with-status: Exported generic functions
Generic Function, time-limit: Exported generic functions
Generic Function, value: Exported generic functions
Generic Function, value-form: Exported generic functions
geq: Internal functions

H
home: Exported generic functions
home: Exported generic functions

I
is: Exported macros
is-values: Exported macros
isnt: Exported macros
isnt-values: Exported macros

L
lformat: Internal macros
locked-package-p: Internal functions

M
Macro, capture-error: Internal macros
Macro, define-fixture-capture: Exported macros
Macro, define-fixture-restore: Exported macros
Macro, define-test: Exported macros
Macro, fail: Exported macros
Macro, false: Exported macros
Macro, finish: Exported macros
Macro, is: Exported macros
Macro, is-values: Exported macros
Macro, isnt: Exported macros
Macro, isnt-values: Exported macros
Macro, lformat: Internal macros
Macro, of-type: Exported macros
Macro, skip: Exported macros
Macro, true: Exported macros
Macro, with-fixtures: Exported macros
Macro, with-forced-status: Exported macros
Macro, with-shuffling: Exported macros
maybe-quote: Internal functions
maybe-unquote: Internal functions
Method, (setf body): Internal generic functions
Method, (setf body): Internal generic functions
Method, (setf body): Internal generic functions
Method, (setf child-status): Internal generic functions
Method, (setf children): Exported generic functions
Method, (setf comparison): Exported generic functions
Method, (setf comparison): Exported generic functions
Method, (setf comparison-geq): Exported generic functions
Method, (setf comparison-geq): Exported generic functions
Method, (setf description): Exported generic functions
Method, (setf description): Exported generic functions
Method, (setf duration): Exported generic functions
Method, (setf expected): Exported generic functions
Method, (setf expected): Exported generic functions
Method, (setf expression): Exported generic functions
Method, (setf fixtures): Exported generic functions
Method, (setf output): Exported generic functions
Method, (setf parent): Exported generic functions
Method, (setf referenced-dependencies): Exported generic functions
Method, (setf referenced-skips): Exported generic functions
Method, (setf results): Exported generic functions
Method, (setf serial): Exported generic functions
Method, (setf status): Exported generic functions
Method, (setf tests): Exported generic functions
Method, (setf time-limit): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf value): Exported generic functions
Method, (setf value-form): Exported generic functions
Method, (setf value-form): Exported generic functions
Method, add-result: Internal generic functions
Method, body: Internal generic functions
Method, body: Internal generic functions
Method, body: Internal generic functions
Method, child-status: Internal generic functions
Method, children: Exported generic functions
Method, children: Exported generic functions
Method, comparison: Exported generic functions
Method, comparison: Exported generic functions
Method, comparison-geq: Exported generic functions
Method, comparison-geq: Exported generic functions
Method, dependencies: Exported generic functions
Method, description: Exported generic functions
Method, description: Exported generic functions
Method, duration: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, eval-in-context: Exported generic functions
Method, expected: Exported generic functions
Method, expected: Exported generic functions
Method, expression: Exported generic functions
Method, find-child-result: Exported generic functions
Method, fixtures: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, format-result: Exported generic functions
Method, home: Exported generic functions
Method, name: Exported generic functions
Method, output: Exported generic functions
Method, parent: Exported generic functions
Method, referenced-dependencies: Exported generic functions
Method, referenced-skips: Exported generic functions
Method, report-on: Exported generic functions
Method, report-on: Exported generic functions
Method, report-on: Exported generic functions
Method, result-for-testable: Exported generic functions
Method, result-for-testable: Exported generic functions
Method, results: Exported generic functions
Method, results-with-status: Exported generic functions
Method, serial: Exported generic functions
Method, skipped-children: Exported generic functions
Method, status: Exported generic functions
Method, summarize: Exported generic functions
Method, summarize: Exported generic functions
Method, tests: Exported generic functions
Method, tests: Exported generic functions
Method, tests-with-status: Exported generic functions
Method, time-limit: Exported generic functions
Method, value: Exported generic functions
Method, value: Exported generic functions
Method, value-form: Exported generic functions
Method, value-form: Exported generic functions

N
name: Exported generic functions
name: Exported generic functions
number-suffix: Internal functions

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

P
package-fixtures: Exported functions
package-tests: Exported functions
parent: Exported generic functions
parent: Exported generic functions
print-oneline: Internal functions

R
referenced-dependencies: Exported generic functions
referenced-dependencies: Exported generic functions
referenced-skips: Exported generic functions
referenced-skips: Exported generic functions
remove-test: Exported functions
removef: Internal functions
report-on: Exported generic functions
report-on: Exported generic functions
report-on: Exported generic functions
report-on: Exported generic functions
resolve-dependency-combination: Internal functions
resolve-tests: Internal functions
restore-fixtures: Exported functions
result-for-testable: Exported generic functions
result-for-testable: Exported generic functions
result-for-testable: Exported generic functions
results: Exported generic functions
results: Exported generic functions
results-with-status: Exported generic functions
results-with-status: Exported generic functions

S
serial: Exported generic functions
serial: Exported generic functions
shuffle: Internal functions
skip: Exported macros
skipped-children: Exported generic functions
skipped-children: Exported generic functions
status: Exported generic functions
status: Exported generic functions
summarize: Exported generic functions
summarize: Exported generic functions
summarize: Exported generic functions

T
test: Exported functions
test-index: Internal functions
tests: Exported generic functions
tests: Exported generic functions
tests: Exported generic functions
tests-with-status: Exported generic functions
tests-with-status: Exported generic functions
time-limit: Exported generic functions
time-limit: Exported generic functions
true: Exported macros

V
value: Exported generic functions
value: Exported generic functions
value: Exported generic functions
value-form: Exported generic functions
value-form: Exported generic functions
value-form: Exported generic functions

W
with-fixtures: Exported macros
with-forced-status: Exported macros
with-shuffling: Exported 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*: Exported special variables
*fixture-captures*: Exported special variables
*fixture-restores*: Exported special variables
*level*: Internal special variables
*parent*: Exported special variables
*real-context*: Internal special variables
*test-indexes*: Internal special variables

B
body: Exported classes
body: Exported classes
body: Internal classes

C
child-status: Internal classes
children: Exported classes
comparison: Exported classes
comparison: Exported classes
comparison-geq: Exported classes
comparison-geq: Exported classes

D
dependencies: Exported classes
description: Exported classes
description: Exported classes
duration: Exported classes

E
expected: Exported classes
expected: Exported classes
expression: Exported classes

F
fixtures: Exported classes

H
home: Exported classes

N
name: Exported classes

O
output: Exported classes

P
parent: Exported classes

R
results: Exported classes

S
serial: Exported classes
skipped-children: Exported classes
Slot, body: Exported classes
Slot, body: Exported classes
Slot, body: Internal classes
Slot, child-status: Internal classes
Slot, children: Exported classes
Slot, comparison: Exported classes
Slot, comparison: Exported classes
Slot, comparison-geq: Exported classes
Slot, comparison-geq: Exported classes
Slot, dependencies: Exported classes
Slot, description: Exported classes
Slot, description: Exported classes
Slot, duration: Exported classes
Slot, expected: Exported classes
Slot, expected: Exported classes
Slot, expression: Exported classes
Slot, fixtures: Exported classes
Slot, home: Exported classes
Slot, name: Exported classes
Slot, output: Exported classes
Slot, parent: Exported classes
Slot, results: Exported classes
Slot, serial: Exported classes
Slot, skipped-children: Exported classes
Slot, status: Exported classes
Slot, tests: Exported classes
Slot, time-limit: Exported classes
Slot, value: Exported classes
Slot, value: Exported classes
Slot, value-form: Exported classes
Slot, value-form: Exported classes
Special Variable, *context*: Exported special variables
Special Variable, *fixture-captures*: Exported special variables
Special Variable, *fixture-restores*: Exported special variables
Special Variable, *level*: Internal special variables
Special Variable, *parent*: Exported special variables
Special Variable, *real-context*: Internal special variables
Special Variable, *test-indexes*: Internal special variables
status: Exported classes

T
tests: Exported classes
time-limit: Exported classes

V
value: Exported classes
value: Exported classes
value-form: Exported classes
value-form: Exported 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   F   I   M   P   Q   R   S   T   V  
Index Entry  Section

C
Class, comparison-result: Exported classes
Class, controlling-result: Internal classes
Class, finishing-result: Exported classes
Class, interactive: Exported classes
Class, multiple-value-comparison-result: Exported classes
Class, multiple-value-result: Exported classes
Class, parent-result: Exported classes
Class, plain: Exported classes
Class, quiet: Exported classes
Class, report: Exported classes
Class, result: Exported classes
Class, test: Exported classes
Class, test-result: Exported classes
Class, value-result: Exported classes
comparison-result: Exported classes
controlling-result: Internal classes

F
finishing-result: Exported classes

I
interactive: Exported classes

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

P
Package, parachute: The parachute package
parachute: The parachute system
parachute: The parachute package
parent-result: Exported classes
plain: Exported classes

Q
quiet: Exported classes

R
report: Exported classes
result: Exported classes

S
System, parachute: The parachute system

T
test: Exported classes
test-result: Exported classes

V
value-result: Exported classes

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