Common Lisp Package: LIFT

README:

FUNCTION

Public

LIFTPROPOS (STRING &KEY (INCLUDE-CASES? NIL) (START-AT 'TEST-MIXIN))

Returns a list of testsuites whose name contains `string`.

LIST-TESTS (&KEY (INCLUDE-CASES? T) (START-AT 'TEST-MIXIN) (STREAM T))

Lists all of the defined test classes from :start-at on down.

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.

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.

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.

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.

Undocumented

ADD-REPORT-HOOK-FOR (MODE HOOK)

COUNT-REPETITIONS (FN DELAY &REST ARGS)

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

LAST-TEST-STATUS

LIFT-PROPERTY (NAME)

SETFLIFT-PROPERTY (VALUE NAME)

REMOVE-TEST (&KEY (TEST-CASE *LAST-TEST-CASE-NAME*) (SUITE *LAST-TESTSUITE-NAME*))

REPORT-HOOKS-FOR (MODE)

SETFREPORT-HOOKS-FOR (VALUE MODE)

SUITE-TESTED-P (SUITE &KEY (RESULT *TEST-RESULT*))

Private

COLLECT-TEST-CASES (&OPTIONAL (START-AT 'TEST-MIXIN))

Returns a list of cons-pairs of testsuites and testcases. The optional parameter provides control over where in the test hierarchy the search begins.

COMPILE-QUICKLY (BODY)

Compile body with as much extra stuff as possible turned `off`. For example, compile without cross-reference information.

CONTAINING-PATHNAME (PATHSPEC)

Return the containing pathname of the thing to which pathspac points. For example: > (containing-directory "/foo/bar/bis.temp") "/foo/bar/" > (containing-directory "/foo/bar/") "/foo/"

COPY-CODE-BLOCK (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-FILE (FROM TO &KEY (IF-DOES-NOT-EXIST ERROR) (IF-EXISTS ERROR))

Copies the file designated by the non-wild pathname designator FROM to the file designated by the non-wild pathname designator TO. The following keyword parameters are supported: * :if-exists this can be either :supersede or :error (the default). If it is :error then a source/target-target-already-exists-error will be signaled if the file designated by the TO pathname already exists. * :if-does-not-exist this can be either :ignore or :error (the default). If it is :error then a source/target-source-does-not-exist-error will be signaled if the FROM pathname designator does not exist.

COPY-STREAM (FROM TO)

Copy into TO from FROM until end of the input stream, in blocks of *stream-buffer-size*. The streams should have the same element type.

DIRECT-SUBCLASSES (THING)

Returns the immediate subclasses of thing. Thing can be a class, object or symbol naming a class.

DOTTED-PAIR-P (PUTATIVE-PAIR)

Returns true if and only if `putative-pair` is a dotted-list. I.e., if `putative-pair` is a cons cell with a non-nil cdr.

FINALIZE-CLASS-IF-NECESSARY (THING)

Finalizes thing if necessary. Thing can be a class, object or symbol naming a class. Returns the class of thing.

FORM-KEYWORD (&REST NAMES)

Finds or interns a symbol in the current package whose name is formed by concatenating the pretty printed representation of the names together.

FORM-SYMBOL (&REST NAMES)

Finds or interns a symbol in the current package whose name is formed by concatenating the pretty printed representation of the names together.

FORM-SYMBOL-IN-PACKAGE (PACKAGE &REST NAMES)

Finds or interns a symbol in package whose name is formed by concatenating the pretty printed representation of the names together.

GET-BACKTRACE-AS-STRING (ERROR)

This is the function that is used internally by Hunchentoot to show or log backtraces. It accepts a condition object ERROR and returns a string with the corresponding backtrace.

LENGTH-1-LIST-P (X)

Is x a list of length 1?

LIFT-RELATIVE-PATHNAME (PATHNAME &OPTIONAL (ERRORP NIL))

Merges pathname with either the path to the currently loading system (if there is one) or the *default-pathname-defaults*.

MAP-SUBCLASSES (CLASS FN &KEY PROPER?)

Applies fn to each subclass of class. If proper? is true, then the class itself is not included in the mapping. Proper? defaults to nil.

MAP-TEST-CASES (FN START-AT)

Call `fn` with each test case for suites starting at `start-at` `fn` should be a function of three arguments. It will called with a testsuite name, a test-case name and the `level` of the suite in the class hierarchy.

PATHNAME-SANS-NAME+TYPE (PATHNAME)

Returns a new pathname with same HOST, DEVICE, DIRECTORY as PATHNAME, and NIL NAME and TYPE components

REMOVE-LEADING-QUOTE (LIST)

Removes the first quote from a list if one is there.

REMOVE-PREVIOUS-DEFINITIONS (CLASSNAME)

Remove the methods of this class and all its subclasses.

SUBCLASSES (CLASS &KEY (PROPER? T))

Returns all of the subclasses of the class including the class itself.

SUPERCLASSES (THING &KEY (PROPER? T))

Returns a list of superclasses of thing. Thing can be a class, object or symbol naming a class. The list of classes returned is 'proper'; it does not include the class itself.

TESTSUITE-RUN (TESTSUITE RESULT)

Run the cases in `testsuite`

VERSION-NUMBERS (VERSION &OPTIONAL PADDED)

Returns a list of the version numbers in a #. delimited string of integers. E.g. (version-numbers "2.2.1") ==> (2 2 1). If the optional `padded` parameter is included, the length of the returned list will be right-padded with zeros so that it is of length padded (the list won't be truncated if padded is smaller than the number of version digits in the string.

WHITESPACEP (CHAR)

Returns true if `char` is an element of [+whitespace-characters+][] and nil otherwise.

Undocumented

%BUILD-ENSURE-COMPARISON (FORM VALUES GUARD-FN TEST TEST-SPECIFIED-P REPORT ARGUMENTS IGNORE-MULTIPLE-VALUES?)

%BUILD-PAIRS (PUTATIVE-PAIRS)

%RUN-TESTS-FROM-FILE (PATH)

%START-TEST-CASE (NAME RESULT)

%START-TEST-SUITE (NAME RESULT)

%TEST-RESULT-REPORT-STREAM (RESULT STREAM FORMAT)

%TOTAL-BYTES-ALLOCATED

%VALID-RUN-SETUP-VALUES

ADD-CODE-BLOCK (NAME PRIORITY OPERATE-WHEN FILTER HANDLER CODE)

BLOCK-NAME (STRUCTURE)

SETFBLOCK-NAME (NEW-VALUE STRUCTURE)

BUILD-BENCHMARK-FUNCTION (SUITE-NAME TEST-CASE-NAME BODY OPTIONS)

BUILD-ISSUES-LIST (RESULT KIND)

BUILD-ISSUES-REPORT (RESULT KIND STREAM)

BUILD-LIFT-ERROR-MESSAGE (CONTEXT MESSAGE &REST ARGUMENTS)

BUILD-RANDOM-INSTANCES-METHOD

BUILD-SETUP-TEST-METHOD

BUILD-TEST-CASE-OPTIONS (SUITE-NAME CASE-NAME OPTIONS)

BUILD-TEST-CLASS

BUILD-TEST-EQUALITY-TEST

BUILD-TEST-LOCAL-FUNCTIONS

BUILD-TEST-TEARDOWN-METHOD

BUILD-TEST-TEST-METHOD (SUITE-NAME TEST-BODY OPTIONS)

BUILD-TESTSUITE-EXPECTED-ERROR

BUILD-TESTSUITE-EXPECTED-FAILURE

CANCEL-TESTING (WHY)

CANONICAL-VERSIONS-NUMBERS (V-1 V-2)

CANONIZE-SKIP-TESTS (SKIP-TESTS)

CHECK-FOR-SURPRISES (SUITE-NAME TEST-CASE-NAME)

CHECK-RUN-SETUP-VALUE

CLASS-SLOT-NAMES (THING)

CLEANUP-PARSED-PARAMETER (PARAMETER)

CODE (STRUCTURE)

SETFCODE (NEW-VALUE STRUCTURE)

COLLECT-TESTSUITE-SUMMARY-FOR-LOG (RESULT KIND)

COLLECT-TESTSUITES (START-AT &KEY FILTER TRANSFORM)

COMPUTE-SUPERCLASS-INHERITENCE

CONFIGURATION-FAILURES (RESULT)

CONVERT-CLAUSES-INTO-LISTS (CLAUSES-AND-OPTIONS CLAUSES-TO-CONVERT)

CURRENT-PROFILE-SAMPLE-COUNT

CURRENT-USER

DATE-STAMP (&KEY (DATETIME (GET-UNIVERSAL-TIME)) (INCLUDE-TIME? NIL) (INCLUDE-DATE? T) (TIME-DELIMITER -) (DATE-DELIMITER -) (DATE-TIME-SEPARATOR T))

DEF (NAME &OPTIONAL (DEFINITION *CURRENT-DEFINITION*))

SETFDEF (VALUE NAME)

DIRECTORY-P (NAME)

DIRECTORY-PATHNAME-P (P)

DIVIDE-CASES (CASES)

DO-TESTING-IN-ENVIRONMENT (SUITE-NAME RESULT FN)

EMPTY-TEST-TABLES (TEST-NAME)

ENCODE-SYMBOL (SYMBOL)

ENSURE-DIRECTORY (PATHNAME)

ENSURE-FUNCTION (THING)

ENSURE-LIST (THING)

ENSURE-STRING (IT)

ENSURE-SYMBOL (THING)

FILTER (STRUCTURE)

SETFFILTER (NEW-VALUE STRUCTURE)

FIND-GENERIC-TEST-CONFIGURATION (&OPTIONAL (ERRORP NIL))

FORM-GROUPS (LIST SIZE)

FORMAT-TEST-TIME-FOR-LOG (TEST-TIME)

GENERATE-PROFILE-LOG-ENTRY (LOG-NAME NAME SECONDS CONSES RESULTS ERROR)

GET-BACKTRACE (ERROR)

GET-TEST-PRINT-LENGTH

GET-TEST-PRINT-LEVEL

GET-TEST-REAL-TIME

HANDLE-CONFIGURATION-PROBLEM (CLASS MESSAGE &REST ARGS)

HANDLE-ERROR-WHILE-TESTING (CONDITION ERROR-CLASS SUITE-NAME RESULT)

HOSTNAME

INITIALIZE-CURRENT-DEFINITION

LIFT-REPORT-CONDITION (C)

LISP-VERSION-STRING

LOOKS-LIKE-SUITE-NAME-P (FORM)

MAKE-CODE-BLOCK (&KEY ((BLOCK-NAME DUM943) NIL) ((PRIORITY DUM944) 0) ((FILTER DUM945) NIL) ((CODE DUM946) NIL) ((OPERATE-WHEN DUM947) NIL))

MAKE-PRINTABLE (THING)

MAKE-PROFILED-FUNCTION (FN)

MAKE-REPORT-ENVIRONMENT

MAKE-TESTSUITE (SUITE-NAME ARGS)

MASSAGE-ARGUMENTS (ARGS)

MASSAGE-CONDITION-STRING (TRIPLE)

MAYBE-ADD-DRIBBLE (STREAM DRIBBLE-STREAM)

MAYBE-RAISE-ENSURE-SAME-CONDITION (VALUE-1 VALUE-2 TEST REPORT &REST ARGUMENTS)

MAYBE-RAISE-NOT-SAME-CONDITION (VALUE-1 VALUE-2 TEST REPORT &REST ARGUMENTS)

MEASURE-FN (FN &REST ARGS)

MOVE-FILE (FROM TO &REST ARGS &KEY (IF-DOES-NOT-EXIST ERROR) (IF-EXISTS ERROR))

OPERATE-WHEN (STRUCTURE)

SETFOPERATE-WHEN (NEW-VALUE STRUCTURE)

PAD-VERSION (V SIZE)

PARSE-BRIEF-SLOT (SLOT)

PARSE-TEST-BODY (TEST-BODY)

PARSE-TEST-SLOTS (SLOT-SPECS)

PATHNAME-HAS-DEVICE-P (PATHNAME)

PATHNAME-HAS-HOST-P (PATHNAME)

PRIORITY (STRUCTURE)

SETFPRIORITY (NEW-VALUE STRUCTURE)

PROPERTY-LIST-P (FORM)

RECORD-END-TIMES (RESULT SUITE)

RECORD-START-TIMES (RESULT SUITE)

RELATIVE-PATHNAME (RELATIVE-TO PATHNAME &KEY NAME TYPE)

REMOVE-TEST-CASE-OPTIONS (SUITE-NAME)

REMOVE-TEST-METHODS (TEST-NAME)

REPORT-ISSUES (RESULT KIND)

REPORT-LIFT-ERROR (CONTEXT MESSAGE &REST ARGUMENTS)

REPORT-SUMMARY-PATHNAME

REPORT-TEST-PROBLEM (PROBLEM-TYPE RESULT SUITE-NAME METHOD CONDITION &REST ARGS)

REPORT-TESTS-BY-SUITE (FORMAT TESTS STREAM)

REWRITE-UNREADABLES (STRING)

RUN-SETUP-P (TESTSUITE)

RUN-TEARDOWN-P (TESTSUITE WHEN)

RUN-TEST-INTERNAL (SUITE TEST-CASE-NAME RESULT)

RUN-TESTS-FROM-FILE (PATH)

RUN-TESTS-INTERNAL (SUITE-NAME RESULT)

SAFE-FIND-SYMBOL (SYMBOL PACKAGE)

SAFE-PARSE-INTEGER (STRING)

SET-DEFINITION (NAME VALUE)

SHOW-CALL-COUNTS (OUTPUT)

SHOW-CALL-GRAPH (OUTPUT)

SHOW-FLAT-PROFILE (OUTPUT)

SIGNAL-LIFT-ERROR (CONTEXT MESSAGE &REST ARGUMENTS)

SKIP-TEST-CASE-P (RESULT SUITE-NAME TEST-CASE-NAME)

SKIP-TEST-SUITE-CHILDREN-P (RESULT SUITE-NAME)

SPLIT (STRING &OPTIONAL (WS '( )))

STANDARD-LOG-DATA

STRING-TRIM-IF (PREDICATE STRING &KEY (START 0) (END (LENGTH STRING)))

STRIP-WHITESPACE (STRING &KEY (START 0) (END (LENGTH STRING)))

SUITES-IN-CASES (CASES)

SUITES-IN-PORTION (CASES PATH)

SUITES-IN-PORTIONS (CASES PATHS)

SYMBOL-APPLY (SYMBOL PACKAGE &REST ARGS)

TEST-CASE-EXPECTS-ERROR-P (SUITE-NAME TEST-CASE-NAME)

TEST-CASE-EXPECTS-FAILURE-P (SUITE-NAME TEST-CASE-NAME)

TEST-CASE-EXPECTS-PROBLEM-P (SUITE-NAME TEST-CASE-NAME)

TEST-CASE-OPTION (SUITE-NAME CASE-NAME OPTION-NAME)

SETFTEST-CASE-OPTION (VALUE SUITE-NAME CASE-NAME OPTION-NAME)

TEST-CASE-P (SUITE-CLASS NAME)

TEST-CASE-SKIPPED-P (RESULT SUITE-NAME CASE-NAME)

TEST-CASE-TESTED-P (SUITE NAME &KEY (RESULT *TEST-RESULT*))

TEST-ENVIRONMENT-VALUE (NAME)

SETFTEST-ENVIRONMENT-VALUE (VALUE NAME)

TEST-FUNCTION-NAME (TEST-FUNCTION)

TEST-REPORT-CODE (SUITE-NAME TEST-CASE-NAME)

TEST-RESULT-PROPERTY (RESULT PROPERTY &OPTIONAL DEFAULT)

SETFTEST-RESULT-PROPERTY (VALUE RESULT PROPERTY)

TEST-RESULTS (&KEY (RESULT *TEST-RESULT*) (FAILURES? T) (ERRORS? T) (SUCCESSES? NIL) (EXPECTED-FAILURES? T) (EXPECTED-ERRORS? T) (SKIPPED-TESTSUITES? NIL) (SKIPPED-TEST-CASES? NIL))

TEST-SUCCESSES (&KEY (RESULT *TEST-RESULT*))

TESTING-INTERACTIVELY-P

TESTSUITE-FAILURES (RESULT)

TESTSUITE-TEST-COUNT (TESTSUITE)

THING-NAMES-GENERIC-FUNCTION-P (THING)

TOTAL-BYTES-ALLOCATED

TRANSLATE-USER (DEST)

UNIQUE-DIRECTORY (PATHNAME)

UNIQUE-FILENAME (PATHNAME &OPTIONAL (MAX-COUNT 10000))

VERSION< (V-1 V-2)

VERSION<= (V-1 V-2)

VERSION= (V-1 V-2)

VERSION> (V-1 V-2)

VERSION>= (V-1 V-2)

WITH-PROFILE-REPORT-FN (NAME STYLE FN BODY &KEY (LOG-NAME *LOG-PATH*) (COUNT-CALLS-P *COUNT-CALLS-P*) (TIMEOUT NIL) DESTINATION)

WRAP-ENCODE-PRE (STRING &KEY (WIDTH 80))

WRITABLE-DIRECTORY-P (DIRECTORY)

WRITE-LOG-HEADER (STREAM RESULT ARGS)

WRITE-PROFILE-REPORT (PATHNAME NAME STYLE BODY SECONDS CONSES ERROR COUNT-CALLS-P)

MACRO

Public

ADDBENCHMARK ((SUITE-NAME &REST OPTIONS) TEST-CASE-NAME &BODY BODY)

Adds a single new test-benchmark to testsuite suite-name.

ADDTEST (NAME &BODY TEST)

Adds a single new test-case to the most recently defined testsuite.

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.

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)

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.

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

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.

ENSURE-NO-WARNING (&BODY BODY)

This macro is used to make sure that body produces no warning.

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.

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

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.

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][].

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.

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.

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.

Undocumented

DEFMEASURE (NAME &KEY (VALUE NIL) (FINALLY NIL) (TYPE NIL) (DOCUMENTATION NIL))

DEFRANDOM-INSTANCE (INSTANCE-TYPE SUITE &BODY BODY)

ENSURE-CASES ((&REST VARS) (&REST CASES) &BODY BODY)

ENSURE-RANDOM-CASES (COUNT (&REST VARS-AND-TYPES) &BODY BODY)

ENSURE-RANDOM-CASES+ (COUNT (&REST VARS) (&REST CASE-FORM) &BODY BODY)

MEASURE-CONSES ((VAR) &BODY BODY)

MEASURE-TIME ((VAR) &BODY BODY)

UNDEFMEASURE (NAME)

WHILE-MEASURING ((CATCH-ERRORS-P &REST MEASURES) &BODY BODY)

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)

Private

DEFCLASS-PROPERTY (PROPERTY &OPTIONAL (DEFAULT NIL DEFAULT-SUPPLIED?))

Create getter and setter methods for 'property' on symbol's property lists.

DEFTEST (TESTSUITE-NAME SUPERCLASSES SLOTS &REST CLAUSES-AND-OPTIONS)

The `deftest` form is obsolete, see [deftestsuite][].

MUFFLE-REDEFINITION-WARNINGS (&BODY BODY)

Evaluate the body so that redefinition warnings will not be signaled. (suppored in Allegro, Clozure CL, CLisp, and Lispworks)

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.

Undocumented

APPEND-TO-REPORT ((VAR OUTPUT-TO) &BODY BODY)

DEFCONDITION (NAME/OPTIONS (&REST SUPER-CONDITIONS) SLOT-SPECS &OPTIONAL FORMAT &REST ARGS &ENVIRONMENT E)

DEFCONFIG (NAME &BODY BODY)

DEFCONFIG-VARIABLE (NAME VAR &OPTIONAL DOCSTRING)

MEASURE (SECONDS BYTES &BODY BODY)

MEASURE-TIME-AND-CONSES (&BODY BODY)

NEWLINIFY (FORMAT &ENVIRONMENT E)

WHILE-MEASURING-1 ((VAR MEASURE) &BODY BODY)

WITH-MEASURING ((VAR MEASURE-FN) &BODY BODY)

WITH-TEST-SLOTS (&BODY BODY)

GENERIC-FUNCTION

Public

FIND-TEST-CASE (SUITE NAME &KEY ERRORP (ERRORP NIL))

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][].

FIND-TESTSUITE (SUITE &KEY ERRORP (ERRORP NIL))

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.

SETUP-TEST (TESTSUITE)

Setup for a test-case. By default it does nothing.

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.

Undocumented

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*) &ALLOW-OTHER-KEYS)

DO-TEST (TESTSUITE TEST-CASE-NAME RESULT)

HANDLE-CONFIG-PREFERENCE (NAME ARGS)

MAKE-TEST-RESULT (FOR TEST-MODE &REST ARGS)

RANDOM-ELEMENT (SUITE SEQUENCE)

RANDOM-INSTANCE-FOR-SUITE (THING SUITE)

RANDOM-NUMBER (SUITE MIN MAX)

TESTSUITE-LOG-DATA (SUITE)

TESTSUITE-TESTS (SYMBOL)

SETFTESTSUITE-TESTS (VALUE SYMBOL)

WRITE-PROFILE-INFORMATION (TESTSUITE)

Private

BLOCK-HANDLER (NAME VALUE)

EQUALITY-TEST (TESTSUITE)

FLET-TEST-FUNCTION (TESTSUITE FUNCTION-NAME &REST ARGS)

GET-CLASS (THING &KEY ERROR?)

Returns the class of thing or nil if the class cannot be found. Thing can be a class, an object representing a class or a symbol naming a class. Get-class is like find-class only not as particular.

TEST-CASE-TEARDOWN (TESTSUITE RESULT)

Tear-down a test-case. By default it does nothing.

TESTSUITE-EXPECTS-ERROR (TESTSUITE)

Returns whether or not the testsuite as a whole expects an error.

TESTSUITE-EXPECTS-FAILURE (TESTSUITE)

Returns whether or not the testsuite as a whole expects to fail.

TESTSUITE-METHODS (TESTSUITE)

Returns a list of the test methods defined for test. I.e., the methods that should be run to do the tests for this testsuite.

TESTSUITE-NAME->METHOD (CLASS NAME)

TESTSUITE-SETUP (TESTSUITE RESULT)

Setup at the testsuite-level

TESTSUITE-TEARDOWN (TESTSUITE RESULT)

Cleanup at the testsuite level.

Undocumented

ACCUMULATE-PROBLEM (PROBLEM RESULT)

BRIEF-PROBLEM-OUTPUT (GLITCH)

DO-TESTING (SUITE RESULT FN)

END-REPORT-OUTPUT (RESULT STREAM FORMAT)

FIND-TEST-CASES (NAME &KEY ERRORP (ERRORP NIL))

FINISH-REPORT-TESTS-BY-SUITE (FORMAT STREAM CURRENT-SUITE)

GENERATE-DETAILED-REPORTS (RESULT STREAM FORMAT)

GENERATE-REPORT-SUMMARY-PATHNAME

HTML-HEADER (STREAM TITLE STYLE-SHEET)

PROBLEM-SUMMARIZATION (PROBLEM)

REPORT-PATHNAME (METHOD &OPTIONAL RESULT)

REPORT-TEST-CASE-BY-SUITE (FORMAT STREAM SUITE TEST-NAME DATUM)

REPORT-TEST-SUITE-BY-SUITE (FORMAT STREAM REMAINING CURRENT-SUITE SUITE)

RESULT-SUMMARY-TAG (PROBLEM STYLE)

SAVE-CONFIGURATION-FILE (RESULT DESTINATION)

SET-TEST-CASE-OPTIONS (SUITE-NAME TEST-CASE-NAME)

SKIP-TEST-CASE (RESULT SUITE-NAME TEST-CASE-NAME)

SKIP-TESTSUITE (RESULT SUITE-NAME)

START-REPORT-OUTPUT (RESULT STREAM FORMAT)

SUMMARIZE-TEST-ENVIRONMENT (RESULT STREAM FORMAT)

SUMMARIZE-TEST-PROBLEMS (RESULT STREAM FORMAT)

SUMMARIZE-TEST-PROBLEMS-OF-TYPE (FORMAT PROBLEMS STREAM ID HEADING NAME)

SUMMARIZE-TEST-RESULT (RESULT STREAM FORMAT)

SUMMARIZE-TESTS-RUN (RESULT STREAM FORMAT)

TEST-CASE-COUNT (TESTSUITE)

TEST-CASE-DOCUMENTATION (SYMBOL)

SETFTEST-CASE-DOCUMENTATION (VALUE SYMBOL)

TEST-CODE->NAME-TABLE (SYMBOL)

SETFTEST-CODE->NAME-TABLE (VALUE SYMBOL)

TEST-NAME->CODE-TABLE (SYMBOL)

SETFTEST-NAME->CODE-TABLE (VALUE SYMBOL)

TEST-NAME->METHODS (SYMBOL)

SETFTEST-NAME->METHODS (VALUE SYMBOL)

TEST-RESULT-REPORT (RESULT OUTPUT FORMAT &KEY PACKAGE (PACKAGE *PACKAGE*) &ALLOW-OTHER-KEYS)

TEST-SLOTS (SYMBOL)

SETFTEST-SLOTS (VALUE SYMBOL)

TESTSUITE-DYNAMIC-VARIABLES (SYMBOL)

SETFTESTSUITE-DYNAMIC-VARIABLES (VALUE SYMBOL)

TESTSUITE-FUNCTION-SPECS (SYMBOL)

SETFTESTSUITE-FUNCTION-SPECS (VALUE SYMBOL)

VALIDATE-REPORT-PROPERTY (NAME ARGS)

WRITE-LOG-TEST (FORMAT SUITE-NAME TEST-CASE-NAME DATA &KEY STREAM)

WRITE-LOG-TEST-END (FORMAT SUITE-NAME TEST-CASE-NAME DATA &KEY STREAM (STREAM *STANDARD-OUTPUT*))

WRITE-LOG-TEST-START (FORMAT SUITE-NAME TEST-CASE-NAME &KEY STREAM (STREAM *STANDARD-OUTPUT*))

SLOT-ACCESSOR

Public

Undocumented

ERRORS (OBJECT)

SETFERRORS (NEW-VALUE OBJECT)

EXPECTED-ERRORS (OBJECT)

SETFEXPECTED-ERRORS (NEW-VALUE OBJECT)

EXPECTED-FAILURES (OBJECT)

SETFEXPECTED-FAILURES (NEW-VALUE OBJECT)

FAILURES (OBJECT)

SETFFAILURES (NEW-VALUE OBJECT)

RESULT-UUID (OBJECT)

SETFRESULT-UUID (NEW-VALUE OBJECT)

SKIPPED-TEST-CASES (OBJECT)

SETFSKIPPED-TEST-CASES (NEW-VALUE OBJECT)

SKIPPED-TESTSUITES (OBJECT)

SETFSKIPPED-TESTSUITES (NEW-VALUE OBJECT)

TEST-CONDITION (OBJECT)

Private

Undocumented

BACKTRACE (OBJECT)

CLASS-DIRECT-SUBCLASSES (CLASS)

CLASS-DIRECT-SUPERCLASSES (CLASS)

CLASS-PRECEDENCE-LIST (PCL-CLASS)

CURRENT-METHOD (OBJECT)

SETFCURRENT-METHOD (NEW-VALUE OBJECT)

CURRENT-STEP (OBJECT)

SETFCURRENT-STEP (NEW-VALUE OBJECT)

DONE-DYNAMICS? (OBJECT)

DONE-SETUP? (OBJECT)

END-TIME (OBJECT)

SETFEND-TIME (NEW-VALUE OBJECT)

END-TIME-UNIVERSAL (OBJECT)

SETFEND-TIME-UNIVERSAL (NEW-VALUE OBJECT)

FAILURE-DOCUMENTATION (OBJECT)

SETFFAILURE-DOCUMENTATION (NEW-VALUE OBJECT)

LOG-FILE (OBJECT)

MAXIMUM-TIME (OBJECT)

SETFMAXIMUM-TIME (NEW-VALUE OBJECT)

NAME (OBJECT)

SETFNAME (NEW-VALUE OBJECT)

PROFILE (OBJECT)

SETFPROFILE (NEW-VALUE OBJECT)

REAL-END-TIME (OBJECT)

SETFREAL-END-TIME (NEW-VALUE OBJECT)

REAL-END-TIME-UNIVERSAL (OBJECT)

SETFREAL-END-TIME-UNIVERSAL (NEW-VALUE OBJECT)

REAL-START-TIME (OBJECT)

REAL-START-TIME-UNIVERSAL (OBJECT)

RESULTS-FOR (OBJECT)

SETFRESULTS-FOR (NEW-VALUE OBJECT)

RUN-SETUP (OBJECT)

START-TIME (OBJECT)

SETFSTART-TIME (NEW-VALUE OBJECT)

START-TIME-UNIVERSAL (OBJECT)

SETFSTART-TIME-UNIVERSAL (NEW-VALUE OBJECT)

SUITES-RUN (OBJECT)

SETFSUITES-RUN (NEW-VALUE OBJECT)

TEST-DATA (OBJECT)

SETFTEST-DATA (NEW-VALUE OBJECT)

TEST-INTERACTIVE? (OBJECT)

SETFTEST-INTERACTIVE? (NEW-VALUE OBJECT)

TEST-METHOD (OBJECT)

TEST-MODE (OBJECT)

SETFTEST-MODE (NEW-VALUE OBJECT)

TEST-PROBLEM-KIND (OBJECT)

TEST-PROBLEM-MESSAGE (OBJECT)

TEST-RESULT-PROPERTIES (OBJECT)

SETFTEST-RESULT-PROPERTIES (NEW-VALUE OBJECT)

TEST-STEP (OBJECT)

TESTS-RUN (OBJECT)

SETFTESTS-RUN (NEW-VALUE OBJECT)

TESTSUITE (OBJECT)

TESTSUITE-INITARGS (OBJECT)

SETFTESTSUITE-INITARGS (NEW-VALUE OBJECT)

TESTSUITE-NAME (OBJECT)

VARIABLE

Public

*CURRENT-ASDF-SYSTEM-NAME*

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.

*CURRENT-TEST*

The current testsuite.

*LIFT-DEBUG-OUTPUT*

Messages from LIFT will be sent to this stream. It can set to nil or to an output stream. It defaults to *debug-io*.

*LIFT-DRIBBLE-PATHNAME*

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.

*LIFT-EQUALITY-TEST*

The function used in ensure-same to test if two things are equal. If metatilities is loaded, then you might want to use samep.

*LIFT-REPORT-PATHNAME*

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

*LOG-TAG*

If set, this is used to tag generated log information.

*PROFILE-STYLE*

Sets the default profiling style to :time, :space, or nil (for no profiling).

*TEST-DESCRIBE-IF-NOT-SUCCESSFUL?*

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.

*TEST-IGNORE-WARNINGS?*

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.

*TEST-MAXIMUM-ERROR-COUNT*

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\*][].

*TEST-MAXIMUM-FAILURE-COUNT*

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\*][].

*TEST-MAXIMUM-TIME*

Maximum number of seconds a process test is allowed to run before we give up.

*TEST-NOTEPAD*

Another place to put things (see {ref *test-scratchpad*}).

*TEST-PRINT-LENGTH*

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*`.

*TEST-PRINT-LEVEL*

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.

*TEST-PRINT-TEST-CASE-NAMES*

If true, LIFT will print the name of each test-case before it runs. See also: *test-print-testsuite-names*.

*TEST-PRINT-TESTSUITE-NAMES*

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

*TEST-RESULT*

Set to the most recent test result by calls to run-test or run-tests.

*TEST-SCRATCHPAD*

A place to put things. This is set to nil before every test.

Undocumented

*COUNT-CALLS-P*

*LOG-DETAIL-HOOKS*

*LOG-HEADER-HOOKS*

*LOG-PATH*

*TEST-BREAK-ON-ERRORS?*

*TEST-BREAK-ON-FAILURES?*

*TEST-EVALUATE-WHEN-DEFINED?*

*TEST-PRINT-WHEN-DEFINED?*

*TEST-SHOW-CODE-P*

*TEST-SHOW-DETAILS-P*

*TEST-SHOW-EXPECTED-P*

Private

*CURRENT-DEFINITION*

An associative-container which saves interesting information about the thing being defined.

*LIFT-IF-DRIBBLE-EXISTS*

Specifies what to do to any existing file at *lift-dribble-pathname*. It can be :supersede, :append, or :error.

*LIFT-STANDARD-OUTPUT*

Output from tests will be sent to this stream. If can set to nil or to an output stream. It defaults to *standard-output*.

*MEASURES*

A list of defineded measures

*REPORT-ENVIRONMENT*

Used internally by LIFT reports.

*SKIP-TESTS*

A lift of test-suites and (testsuite test-case) pairs that LIFT will ignore during calls to run-tests.

*TEST-METADATA*

A place for LIFT to put stuff.

*TESTSUITE-TEST-COUNT*

Temporary variable used to 'communicate' between deftestsuite and addtest.

+WHITESPACE-CHARACTERS+

A list of characters that should be treated as whitespace. See, for example, [whitespacep][].

Undocumented

*CODE-BLOCKS*

*CONFIG-DRIBBLE-PATHNAME*

*CURRENT-CONFIGURATION-STREAM*

*CURRENT-TEST-CASE-NAME*

*CURRENT-TESTSUITE-NAME*

*CURRENT-USER*

*DEFTEST-CLAUSES*

*FUNCTIONS-TO-PROFILE*

*HOSTNAME*

*HTML-META*

*IN-MIDDLE-OF-FAILURE?*

*LAST-TEST-CASE-NAME*

*LAST-TESTSUITE-NAME*

*PROFILING-THRESHOLD*

*REPORT-HOOKS*

*STREAM-BUFFER-SIZE*

*TEST-CASE-OPTIONS*

*TEST-IS-BEING-COMPILED?*

*TEST-IS-BEING-DEFINED?*

*TEST-IS-BEING-EXECUTED?*

*TEST-IS-BEING-LOADED?*

*TEST-RUN-SUBSUITES?*

+A-DOUBLE-FLOAT+

+A-SINGLE-FLOAT+

+A-SYMBOL+

+AN-INTEGER+

+LIFT-CONFUSED-ABOUT-ARGUMENTS+

+LIFT-COULD-NOT-FIND-TEST+

+LIFT-NO-CURRENT-TEST-CLASS+

+LIFT-TEST-CLASS-NOT-FOUND+

+LIFT-TEST-NAME-NOT-SUPPLIED-WITH-TEST-CLASS+

+LIFT-UNABLE-TO-PARSE-TEST-NAME-AND-CLASS+

+RUN-TESTS-NULL-TEST-CASE+

CLASS

Public

TEST-MIXIN

A test suite

TEST-RESULT

A `test-result` instance contains all of the information collectd by LIFT during a test run.

Undocumented

A-DOUBLE-FLOAT

A-SINGLE-FLOAT

A-SYMBOL

AN-INTEGER

LOG-RESULTS-MIXIN

Private

Undocumented

EXPECTED-PROBLEM-MIXIN

PROCESS-TEST-MIXIN

TEST-CONFIGURATION-ERROR

TEST-CONFIGURATION-FAILURE

TEST-CONFIGURATION-PROBLEM-MIXIN

TEST-ERROR

TEST-ERROR-MIXIN

TEST-EXPECTED-ERROR

TEST-EXPECTED-FAILURE

TEST-FAILURE

TEST-FAILURE-MIXIN

TEST-PROBLEM-MIXIN

TEST-SERIOUS-CONDITION

TEST-TIMEOUT-FAILURE

TESTCASE-SKIPPED

TESTSUITE-ERROR

TESTSUITE-FAILURE

TESTSUITE-PROBLEM-MIXIN

TESTSUITE-SERIOUS-CONDITION

TESTSUITE-SKIPPED

CONDITION

Public

Undocumented

ENSURE-CASES-FAILURE

ENSURE-EXPECTED-CONDITION

ENSURE-EXPECTED-NO-WARNING-CONDITION

ENSURE-FAILED-ERROR

ENSURE-NOT-SAME

ENSURE-NULL-FAILED-ERROR

ENSURE-RANDOM-CASES-FAILURE

ENSURE-SAME (FORM VALUES &KEY (TEST NIL TEST-SPECIFIED-P) (REPORT NIL) (ARGUMENTS NIL) (IGNORE-MULTIPLE-VALUES? NIL))

FAILED-COMPARISON-CONDITION

TEST-CASE-AMBIGUOUS

TEST-CASE-NOT-DEFINED

TEST-CONDITION (OBJECT)

TEST-TIMEOUT-CONDITION

TESTSUITE-AMBIGUOUS

TESTSUITE-NOT-DEFINED

UNEXPECTED-SUCCESS-FAILURE

Private

SOURCE/TARGET-FILE-ERROR

General condition for file errors that have a source and target.

SOURCE/TARGET-SOURCE-DOES-NOT-EXIST-ERROR

This error is signaled when the source file does not exist.

SOURCE/TARGET-TARGET-ALREADY-EXISTS-ERROR

This error is signaled when the target pathname already exists.

TIMEOUT-ERROR

An error signaled when the duration specified in the [with-timeout][] is exceeded.

Undocumented

LIFT-COMPILE-ERROR