lift

API Reference

lift

LIsp Framework for Testing

COM.METABANG.TRIVIAL-TIMEOUT

  • Condition TIMEOUT-ERROR  (ERROR)
    An error signaled when the duration specified in the [with-timeout][] is exceeded.
  • Macro WITH-TIMEOUT ((seconds) &body body)
    Execute `body` for no more than `seconds` time. If `seconds` is exceeded, then a [timeout-error][] will be signaled. If `seconds` is nil, then the body will be run normally until it completes or is interrupted.

LIFT

  • Variable *LIFT-DEBUG-OUTPUT*
    *debug-io*
    Messages from LIFT will be sent to this stream. It can set to nil or to an output stream. It defaults to *debug-io*.
  • Variable *TEST-PRINT-TESTSUITE-NAMES*
    t
    If true, LIFT will print the name of each test suite to *debug-io* before it begins to run the suite. See also: *test-print-test-case-names*.
  • Variable *TEST-PRINT-TEST-CASE-NAMES*
    nil
    If true, LIFT will print the name of each test-case before it runs. See also: *test-print-testsuite-names*.
  • Macro UNDEFMEASURE (name)
  • Macro DEFMEASURE (name &key (value nil) (finally nil) (type nil) (documentation nil))
  • Macro WHILE-MEASURING ((catch-errors-p &rest measures) &body body)
  • Macro WITH-PROFILE-REPORT ((name style &key (log-name *log-path* ln-supplied?) (count-calls-p *count-calls-p* ccp-supplied?) (timeout nil timeout-supplied?) (destination nil distination-supplied?)) &body body)
  • Macro WHILE-COUNTING-REPETITIONS ((&optional (delay 1.0)) &body body)
    Execute `body` repeatedly for `delay` seconds. Returns the number of times `body` is executed per second. Warning: assumes that `body` will not be executed more than a fixnum number of times. The `delay` defaults to 1.0.
  • Macro WHILE-COUNTING-REPETITIONS* ((&optional (delay 1.0)) &body body)
    Count the number of times `body` executes in `delay` seconds. Warning: assumes that `body` will not be executed more than a fixnum number of times. The `delay` defaults to 1.0. Unlike [while-counting-repetitions][] , this does not use with-timeout and therefore assumes that `body` executes quickly relative to delay.
  • Macro WHILE-COUNTING-EVENTS ((&optional (delay 1.0)) &body body)
    Returns the count of the number of times `did-event` was called during `delay` seconds. See also: [while-counting-repetitions][].
  • Macro WHILE-COUNTING-EVENTS* ((&optional (delay 1.0)) &body body)
    Count the number of times `did-event` is called `body` during `delay`. Warning: assumes that `body` will not be executed more than a fixnum number of times. The `delay` defaults to 1.0. Unlike [while-counting-events][] , this does not use with-timeout and therefore assumes that `body` executes quickly relative to delay.
  • Macro ENSURE (predicate &key report arguments)
    If ensure's `predicate` evaluates to false, then it will generate a test failure. You can use the `report` and `arguments` keyword parameters to customize the report generated in test results. For example: (ensure (= 23 12) :report "I hope ~a does not = ~a" :arguments (12 23)) will generate a message like Warning: Ensure failed: (= 23 12) (I hope 12 does not = 23)
  • Macro ENSURE-NULL (predicate &key report arguments)
    If ensure-null's `predicate` evaluates to true, then it will generate a test failure. You can use the `report` and `arguments` keyword parameters to customize the report generated in test results. See [ensure][] for more details.
  • Macro ENSURE-CONDITION (condition &body body)
    Signal a test-failure if `body` does not signal `condition`. If `condition` is an atom, then non-error conditions will _not_ cause a failure. `condition` may also be a list of the form (condition &key catch-all-conditions? report arguments name validate) If this form is used then the values are uses as follows: * report and arguments are used to display additional information when the ensure fails. * `catch-all-conditions? - if true, then the signaling of _any_ other condition will cause a test failure. * validate - if supplied, this will be evaluated when the condition is signaled with the condition bound to the variable `condtion` (unless name is used to change this). `validate` can be used to ensure additional constaints on the condition. * name - if supplied, this will be the name of the variable bound to the condition in the validate clause.
  • Macro ENSURE-NO-WARNING (&body body)
    This macro is used to make sure that body produces no warning.
  • Macro ENSURE-WARNING (&body body)
    Ensure-warning evaluates its body. If the body does *not* signal a warning, then ensure-warning will generate a test failure.
  • Macro ENSURE-ERROR (&body body)
    Ensure-error evaluates its body. If the body does *not* signal an error, then ensure-error will generate a test failure.
  • Macro ENSURE-SAME (form values &key (test nil test-specified-p) (report nil) (arguments nil) (ignore-multiple-values? nil))
    Ensure same compares value-or-values-1 value-or-values-2 or each value of value-or-values-1 value-or-values-2 (if they are multiple values) using test. If a comparison fails ensure-same raises a warning which uses `report` as a format string and `arguments` as arguments to that string (if report and arguments are supplied). If ensure-same is used within a test, a test failure is generated instead of a warning
  • Macro ENSURE-DIFFERENT (form values &key (test nil test-specified-p) (report nil) (arguments nil) (ignore-multiple-values? nil))
    Ensure-different compares value-or-values-1 value-or-values-2 or each value of value-or-values-1 and value-or-values-2 (if they are multiple values) using test. If any comparison returns true, then ensure-different raises a warning which uses report as a format string and `arguments` as arguments to that string (if report and `arguments` are supplied). If ensure-different is used within a test, a test failure is generated instead of a warning
  • Macro ENSURE-CASES ((&rest vars) (&rest cases) &body body)
    Run `body` with multiple bindings for a set of variables. * `vars` must be a list of variable names (not evaluated) * `cases` is a list of lists of bindings for the `vars` (evaluated). If there is only a single variable (i.e., `vars` is a one-element list), then `cases` can also be a simple list. As an example, here is how we could test that an addition function worked correctly: (ensure-cases (a b result) `((1 2 3) (1 -1 0) (1.1 0.9 2.0)) (ensure-same (add-em a b) result :test '=)) All cases are evaluated even if there are failures or errors during the testing. The test report will contain a list of all of the failing cases.
  • Variable *LOG-TAG*
    nil
    If set, this is used to tag generated log information.
  • Variable *TEST-MAXIMUM-ERROR-COUNT*
    nil
    The maximum numbers of errors to allow during a [run-tests][]. If `*test-maximum-error-count*` is nil, then a call to run-tests will continue regardless of the number of errors. If it a positive integer, then run-tests will stop as soon as the number of test-errors if greater than or equal to its value. Setting this to some small value can help prevent running lengthly test-suites when there are many errors. See also [\*test-maximum-failure-count\*][].
  • Variable *TEST-MAXIMUM-FAILURE-COUNT*
    nil
    The maximum numbers of failures to allow during a [run-tests][]. If `*test-maximum-failure-count*` is nil, then a call to run-tests will continue regardless of the number of failures. If it a positive integer, then run-tests will stop as soon as the number of test-failures if greater than or equal to its value. Setting this to some small value can help prevent running lengthly test-suites when there are many failures. See also [\*test-maximum-error-count\*][].
  • Variable *TEST-MAXIMUM-TIME*
    2
    Maximum number of seconds a process test is allowed to run before we give up.
  • Variable *TEST-BREAK-ON-ERRORS?*
    nil
  • Variable *TEST-BREAK-ON-FAILURES?*
    nil
  • Variable *BREAK-ON-REDEFINITION*
    nil
  • Variable *TEST-IGNORE-WARNINGS?*
    nil
    If true, LIFT will not cause a test to fail if a warning occurs while the test is running. Note that this may interact oddly with ensure-warning.
  • Variable *TEST-PRINT-WHEN-DEFINED?*
    nil
  • Variable *TEST-EVALUATE-WHEN-DEFINED?*
    t
  • Variable *TEST-SCRATCHPAD*
    nil
    A place to put things. This is set to nil before every test.
  • Variable *TEST-NOTEPAD*
    nil
    Another place to put things (see {ref *test-scratchpad*}).
  • Variable *LIFT-EQUALITY-TEST*
    'equal
    The function used in ensure-same to test if two things are equal. If metatilities is loaded, then you might want to use samep.
  • Variable *TEST-DESCRIBE-IF-NOT-SUCCESSFUL?*
    nil
    If true, then a complete test description is printed when there are any test warnings or failures. Otherwise, one would need to explicity call describe.
  • Variable *TEST-PRINT-LENGTH*
    :follow-print
    The print-length in effect when LIFT prints test results. It works exactly like `*print-length*` except that it can also take on the value :follow-print. In this case, it will be set to the value of `*print-length*`.
  • Variable *TEST-PRINT-LEVEL*
    :follow-print
    The print-level in effect when LIFT prints test results. It works exactly like `*print-level*` except that it can also take on the value :follow-print. In this case, it will be set to whatever `*print-level*` is.
  • Variable *TEST-RESULT*
    nil
    Set to the most recent test result by calls to run-test or run-tests.
  • Variable *CURRENT-TEST*
    nil
    The current testsuite.
  • Variable *LIFT-DRIBBLE-PATHNAME*
    nil
    If bound, then test output from run-tests will be sent to this file in in addition to *lift-standard-output*. It can be set to nil or to a pathname.
  • Variable *LIFT-REPORT-PATHNAME*
    nil
    If bound to a pathname or stream, then a summary of test information will be written to it for later processing. It can be set to: * `nil` - generate no output * pathname designator - send output to this pathname * `t` - send output to a pathname constructed from the name of the system being tested (this only works if ASDF is being used to test the system). As an example of the last case, if LIFT is testing a system named ...
  • Variable *TEST-SHOW-EXPECTED-P*
    t
  • Variable *TEST-SHOW-DETAILS-P*
    t
  • Variable *TEST-SHOW-CODE-P*
    t
  • Variable *LOG-PATH*
    (asdf/system:system-relative-pathname 'lift::lift
                                          "benchmark-data/benchmarks.log")
  • Variable *COUNT-CALLS-P*
    nil
  • Variable *PROFILE-STYLE*
    nil
    Sets the default profiling style to :time, :space, or nil (for no profiling).
  • Class TEST-MIXIN
    A test suite
    NAME   Accessor: NAME   Reader: TESTSUITE-NAME
    RUN-SETUP   Reader: RUN-SETUP
    DONE-SETUP?   Reader: DONE-SETUP?
    DONE-DYNAMICS?   Reader: DONE-DYNAMICS?
    CURRENT-METHOD   Accessor: CURRENT-METHOD
    LOG-FILE   Reader: LOG-FILE
    TEST-DATA   Accessor: TEST-DATA
    TEST-SOURCE-FILE   Accessor: TEST-SOURCE-FILE
    PROFILE   Accessor: PROFILE
  • Class LOG-RESULTS-MIXIN  (TEST-MIXIN)
    No slots.
  • Class TEST-RESULT
    A `test-result` instance contains all of the information collectd by LIFT during a test run.
    RESULTS-FOR   Accessor: RESULTS-FOR
    TESTS-RUN   Accessor: TESTS-RUN
    SUITES-RUN   Accessor: SUITES-RUN
    FAILURES   Accessor: FAILURES
    EXPECTED-FAILURES   Accessor: EXPECTED-FAILURES
    ERRORS   Accessor: ERRORS
    EXPECTED-ERRORS   Accessor: EXPECTED-ERRORS
    SKIPPED-TEST-CASES   Accessor: SKIPPED-TEST-CASES
    SKIPPED-TESTSUITES   Accessor: SKIPPED-TESTSUITES
    TEST-MODE   Accessor: TEST-MODE
    TEST-INTERACTIVE?   Accessor: TEST-INTERACTIVE?
    REAL-START-TIME   Reader: REAL-START-TIME
    START-TIME   Accessor: START-TIME
    END-TIME   Accessor: END-TIME
    REAL-END-TIME   Accessor: REAL-END-TIME
    REAL-START-TIME-UNIVERSAL   Reader: REAL-START-TIME-UNIVERSAL
    START-TIME-UNIVERSAL   Accessor: START-TIME-UNIVERSAL
    END-TIME-UNIVERSAL   Accessor: END-TIME-UNIVERSAL
    REAL-END-TIME-UNIVERSAL   Accessor: REAL-END-TIME-UNIVERSAL
    PROPERTIES   Accessor: TEST-RESULT-PROPERTIES
    CURRENT-STEP   Accessor: CURRENT-STEP
    TESTSUITE-INITARGS   Accessor: TESTSUITE-INITARGS
    UUID   Accessor: RESULT-UUID
  • Generic-Function DO-TEST (testsuite test-case-name result)
  • Generic-Function SETUP-TEST (testsuite)
    Setup for a test-case. By default it does nothing.
  • Generic-Function TESTSUITE-P (thing)
    Determine whether or not `thing` is a testsuite. Thing can be a symbol naming a suite, a subclass of `test-mixin` or an instance of a test suite. Returns nil if `thing` is not a testsuite and the symbol naming the suite if it is.
  • Generic-Function DESCRIBE-TEST-RESULT (result stream &key &allow-other-keys)
  • Generic-Function WRITE-PROFILE-INFORMATION (testsuite)
  • Generic-Function MAKE-TEST-RESULT (for test-mode &rest args)
  • Generic-Function TESTSUITE-LOG-DATA (suite)
  • Condition TESTSUITE-NOT-DEFINED  (LIFT-COMPILE-ERROR)
  • Condition TESTSUITE-AMBIGUOUS  (LIFT-COMPILE-ERROR)
  • Condition TEST-CASE-NOT-DEFINED  (LIFT-COMPILE-ERROR)
  • Condition TEST-CASE-AMBIGUOUS  (LIFT-COMPILE-ERROR)
  • Condition TEST-CONDITION  (WARNING)
  • Condition TEST-TIMEOUT-CONDITION  (TEST-CONDITION)
  • Condition ENSURE-FAILED-ERROR  (TEST-CONDITION)
  • Condition ENSURE-NULL-FAILED-ERROR  (ENSURE-FAILED-ERROR)
  • Condition ENSURE-EXPECTED-CONDITION  (TEST-CONDITION)
  • Condition ENSURE-EXPECTED-NO-WARNING-CONDITION  (TEST-CONDITION)
  • Condition FAILED-COMPARISON-CONDITION  (TEST-CONDITION)
  • Condition ENSURE-NOT-SAME  (FAILED-COMPARISON-CONDITION)
  • Condition ENSURE-SAME  (FAILED-COMPARISON-CONDITION)
  • Condition ENSURE-CASES-FAILURE  (TEST-CONDITION)
  • Condition UNEXPECTED-SUCCESS-FAILURE  (TEST-CONDITION)
  • Method WRITE-PROFILE-INFORMATION ((suite t))
  • Method SETUP-TEST ((test test-mixin))
  • Method SETUP-TEST ((test test-mixin))
  • Method SETUP-TEST ((test symbol))
  • Macro DEFTESTSUITE (testsuite-name superclasses slots &rest clauses-and-options)
    Creates a testsuite named `testsuite-name` and, optionally, the code required for test setup, test tear-down and the actual test-cases. A testsuite is a collection of test-cases and other testsuites. Test suites can have multiple superclasses (just like the classes that they are). Usually, these will be other test classes and the class hierarchy becomes the test case hierarchy. If necessary, however, non-testsuite classes can also be used as superclasses. Slots are specified as in defclass with the following additions: * Initargs and accessors are automatically defined. If a slot is named`my-slot`, then the initarg will be `:my-slot` and the accessors will be `my-slot` and `(setf my-slot)`. * If the second argument is not a CLOS slot option keyword, then it will be used as the `:initform` for the slot. I.e., if you have (deftestsuite my-test () ((my-slot 23))) then `my-slot` will be initialized to 23 during test setup. Test options are one of :setup, :teardown, :test, :tests, :documentation, :export-p, :dynamic-variables, :export-slots, :function, :categories, :run-setup, or :equality-test. * :categories - a list of symbols. Categories allow you to groups tests into clusters outside of the basic hierarchy. This provides finer grained control on selecting which tests to run. May be specified multiple times. * :documentation - a string specifying any documentation for the test. Should only be specified once. * :dynamic-variables - a list of atoms or pairs of the form (name value). These specify any special variables that should be bound in a let around the body of the test. The name should be symbol designating a special variable. The value (if supplied) will be bound to the variable. If the value is not supplied, the variable will be bound to nil. Should only be specified once. * :equality-test - the name of the function to be used by default in calls to ensure-same and ensure-different. Should only be supplied once. * :export-p - If true, the testsuite name will be exported from the current package. Should only be specified once. * :export-slots - if true, any slots specified in the test suite will be exported from the current package. Should only be specified once. * :function - creates a locally accessible function for this test suite. May be specified multiple times. * :run-setup - specify when to run the setup code for this test suite. Allowed values are * :once-per-test-case or t (the default) * :once-per-session * :once-per-suite * :never or nil :run-setup is handy when a testsuite has a time consuming setup phase that you do not want to repeat for every test. * :setup - a list of forms to be evaluated before each test case is run. Should only be specified once. * :teardown - a list of forms to be evaluated after each test case is run. Should only be specified once. * :test - Define a single test case. Can be specified multiple times. * :tests - Define multiple test cases for this test suite. Can be specified multiple times.
  • Macro ADDTEST (name &body test)
    Adds a single new test-case to the most recently defined testsuite.
  • Macro ADDBENCHMARK ((suite-name &rest options) test-case-name &body body)
    Adds a single new test-benchmark to testsuite suite-name.
  • Function REMOVE-TEST (&key (test-case *last-test-case-name*) (suite *last-testsuite-name*))
  • Method MAKE-TEST-RESULT (for test-mode &rest args)
  • Method DESCRIBE-TEST-RESULT (result stream &key (show-details-p *test-show-details-p*) (show-expected-p *test-show-expected-p*) (show-code-p *test-show-code-p*))
  • Method SETUP-TEST ((test test-mixin))
  • Generic-Function TESTSUITE-TESTS (symbol)
  • Generic-Function (setf TESTSUITE-TESTS) (value symbol)
  • Method TESTSUITE-TESTS ((class-name symbol))
  • Method (setf TESTSUITE-TESTS) (value (class-name symbol))
  • Method DO-TEST ((suite test-mixin) name result)
  • Method DO-TEST ((suite process-test-mixin) name result)
  • Method TESTSUITE-LOG-DATA ((suite t))
  • Method TESTSUITE-LOG-DATA ((suite t))
  • Function LIFT-PROPERTY (name)
  • Function (setf LIFT-PROPERTY) (value name)
  • Condition ENSURE-RANDOM-CASES-FAILURE  (TEST-CONDITION)
  • Generic-Function RANDOM-INSTANCE-FOR-SUITE (thing suite)
  • Macro DEFRANDOM-INSTANCE (instance-type suite &body body)
  • Macro ENSURE-RANDOM-CASES (count (&rest vars-and-types) &body body)
  • Macro ENSURE-RANDOM-CASES+ (count (&rest vars) (&rest case-form) &body body)
  • Generic-Function RANDOM-NUMBER (suite min max)
  • Generic-Function RANDOM-ELEMENT (suite sequence)
  • Method RANDOM-NUMBER (suite min max)
  • Method RANDOM-ELEMENT (suite sequence)
  • Class AN-INTEGER
    No slots.
  • Method RANDOM-INSTANCE-FOR-SUITE ((thing an-integer) (suite test-mixin))
  • Class A-SINGLE-FLOAT
    No slots.
  • Method RANDOM-INSTANCE-FOR-SUITE ((thing a-single-float) (suite test-mixin))
  • Class A-DOUBLE-FLOAT
    No slots.
  • Method RANDOM-INSTANCE-FOR-SUITE ((thing a-double-float) (suite test-mixin))
  • Class A-SYMBOL
    No slots.
  • Method RANDOM-INSTANCE-FOR-SUITE ((thing a-symbol) (suite test-mixin))
  • Macro MEASURE-TIME ((var) &body body)
  • Macro MEASURE-CONSES ((var) &body body)
  • Function GENERATE-LOG-ENTRY (name seconds conses &key (log-name *log-path*) results error (sample-count (and (current-profile-sample-count) (plusp (current-profile-sample-count)))) (additional-data nil))
  • Function COUNT-REPETITIONS (fn delay &rest args)
  • Generic-Function HANDLE-CONFIG-PREFERENCE (name args)
  • Variable *CURRENT-ASDF-SYSTEM-NAME*
    nil
    Holds the name of the system being tested when using the `:generic` configuration. LIFT needs this to run the `:generic` configuration because this is how it determines which configuration file to load. If you use `asdf:test-op` then this value will be set automatically. Otherwise, you will need to set it yourself.
  • Method HANDLE-CONFIG-PREFERENCE ((name t) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :include)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :log-tag)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :dribble)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :debug-output)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :standard-output)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :break-on-errors?)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :break-on-failures?)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :do-children?)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :equality-test)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :print-length)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :print-level)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :print-suite-names)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :print-test-case-names)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :if-dribble-exists)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :report-property)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :profiling-threshold)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :count-calls-p)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :log-pathname)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :maximum-failures)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :maximum-failure-count)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :maximum-errors)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :maximum-error-count)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :profile-style)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :build-report)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :trace)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :untrace)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :skip-tests-reset)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :skip-testsuites)) args)
  • Method HANDLE-CONFIG-PREFERENCE ((name (eql :skip-tests)) args)
  • Variable *LOG-HEADER-HOOKS*
    nil
  • Variable *LOG-FOOTER-HOOKS*
    nil
  • Variable *LOG-DETAIL-HOOKS*
    nil
  • Function REPORT-HOOKS-FOR (mode)
  • Function (setf REPORT-HOOKS-FOR) (value mode)
  • Function ADD-REPORT-HOOK-FOR (mode hook)
  • Generic-Function FIND-TESTSUITE (suite &key errorp)
    Search for a testsuite named `suite`. The search is conducted across all packages so `suite` can be a symbol in any package. I.e., find-testsuite looks for testsuite classes whose symbol-name is string= to `suite`. If `errorp` is true, then find-testsuite can raise two possible errors: * If more than one matching testsuite is found, then an error of type `testsuite-ambiguous` will be raised. * If no matching testsuites are found, then an error of type `testsuite-not-defined` will be raised. The default for `errorp` is nil.
  • Generic-Function FIND-TEST-CASE (suite name &key errorp)
    Search for a test-case named `name` in a testsuite named `suite`. The search is conducted across all packages so `suite` and `name` can be symbols in any package. I.e., find-test-case looks for a testsuites and test-cases whose symbol-names are string= to `suite` and `name`. If `errorp` is true, then find-test-case can raise two possible errors: * If more than one matching test-case is found, then an error of type `test-case-ambiguous` will be raised. * If no matching test-cases are found, then an error of type `test-case-not-defined` will be raised. The default for `errorp` is nil. If `suite` is nil, then find-test-case will search for matching test-cases across all suites. This is equivalent to the behavior of [find-test-cases][].
  • Method TESTSUITE-P ((classname symbol))
  • Method TESTSUITE-P ((object standard-object))
  • Method TESTSUITE-P ((class standard-class))
  • Function LIFTPROPOS (string &key (include-cases? nil) (start-at 'test-mixin))
    Returns a list of testsuites whose name contains `string`.
  • Function MAP-TESTSUITES (fn start-at)
    Call `fn` with each suite name starting at `start-at` `fn` should be a function of two arguments. It will called with a testsuite name and the `level` of the suite in the class hierarchy.
  • Function TESTSUITES (&optional (start-at 'test-mixin))
    Returns a list of testsuite classes. The optional parameter provides control over where in the test hierarchy the search begins.
  • Function PRINT-TESTS (&key (include-cases? t) (start-at 'test-mixin) (stream t))
    Prints all of the defined test classes from :start-at on down.
  • Function LIST-TESTS (&key (include-cases? t) (start-at 'test-mixin) (stream t))
    Lists all of the defined test classes from :start-at on down.
  • Method FIND-TESTSUITE ((suite test-mixin) &key (errorp nil))
  • Method FIND-TESTSUITE ((suite symbol) &key (errorp nil))
  • Method FIND-TESTSUITE ((suite-name string) &key (errorp nil))
  • Method FIND-TEST-CASE ((suite symbol) name &key (errorp nil))
  • Method FIND-TEST-CASE ((suite null) name &key (errorp nil))
  • Method FIND-TEST-CASE ((suite test-mixin) name &key (errorp nil))
  • Method FIND-TEST-CASE ((suite-class standard-class) (name symbol) &key (errorp nil))
  • Method FIND-TEST-CASE ((suite test-mixin) (name string) &key (errorp nil))
  • Method FIND-TEST-CASE ((suite-class standard-class) (name string) &key (errorp nil))
  • Function LAST-TEST-STATUS
  • Function SUITE-TESTED-P (suite &key (result *test-result*))
  • Function RUN-TEST (&key (name *last-test-case-name*) (suite *last-testsuite-name*) (break-on-errors? *test-break-on-errors?*) (break-on-failures? *test-break-on-failures?*) (result nil) (profile *profile-style* profile-supplied?) (testsuite-initargs nil))
    Run a single test-case in a testsuite. Will run the most recently defined or run testcase unless the name and suite arguments are used to override them.
  • Function RUN-TESTS (&rest args &key (suite nil) (break-on-errors? *test-break-on-errors?*) (break-on-failures? *test-break-on-failures?*) (config nil) (dribble *lift-dribble-pathname*) (report-pathname *lift-report-pathname*) (profile *profile-style* profile-supplied?) (skip-tests *skip-tests*) (do-children? *test-run-subsuites?*) (testsuite-initargs nil) result &allow-other-keys)
    Run all of the tests in a suite.
  • Method DO-TEST ((suite test-mixin) name result)

lift-documentation

Documentation for LIFT

No packages.