Simple suite and tests in the repl

STEFIL-TEST> (defsuite demo)
#<test DEMO>
STEFIL-TEST> (in-suite demo)
DEMO
STEFIL-TEST> (deftest car-is-42 (x)
               (is (= (car x) 42))
               (car x))
CAR-IS-42
STEFIL-TEST> (deftest test-calling-test ()
               (car-is-42 (list 42))
               (is (eq (car-is-42 (list 43)) 43)))
TEST-CALLING-TEST
STEFIL-TEST> (demo)
.X.
#<test-run 3 tests, 3 assertions, 1 failures in 0.012 sec>

The inspected test result

Stefil test results

Executed tests: 3
Executed assertions: 3

List of failures (1): [rerun all failed tests]
  [rerun] #<failure (IS (= (CAR X) 42)) backtrace: CAR-IS-42,TEST-CALLING-TEST,DEMO>

[show all slots]

The inspected failure

Failed Stefil assertion

Form: (IS (= (CAR X) 42))

Test backtrace:
  0: #<test-run (CAR-IS-42 (43))> [rerun]
  1: #<test-run (TEST-CALLING-TEST)> [rerun]
  2: #<test-run (DEMO)> [rerun]

[show all slots]

An inspected test

Stefil test

Name:                    CAR-IS-42  [undefine]
Package:                 #<PACKAGE "STEFIL-TEST">
Compile before run?:     yes
Auto call by its suite?: yes
Documentation:           
Parent:                  #<test DEMO :tests 2> [run]

[hide slots]
List of all slots:
  AUTO-CALL          = T [set value] [make unbound]
  BODY               = ((LET ((*SUITE* *STEFIL-TEMP-SUITE*)) (IS (= (CAR X) 42)) (CAR X))) [set value] [make unbound]
  CHILDREN           = #<HASH-TABLE :TEST EQL :COUNT 0 {CC88F29}> [set value] [make unbound]
  COMPILE-BEFORE-RUN = T [set value] [make unbound]
  DECLARATIONS       = NIL [set value] [make unbound]
  DOCUMENTATION      = NIL [set value] [make unbound]
  LAMBDA-LIST        = (X) [set value] [make unbound]
  NAME               = CAR-IS-42 [set value] [make unbound]
  PACKAGE            = #<PACKAGE "STEFIL-TEST"> [set value] [make unbound]
  PARENT             = #<test DEMO :tests 2> [set value] [make unbound]

Slime debugger with the restarts

Test assertion failed:

Binary predicate (= X Y) failed.
x: (CAR X) => 43
y: 42 => 42
   [Condition of type STEFIL::ASSERTION-FAILED]

Restarts:
 10: CONTINUE                   Record the failure and continue
 9: CONTINUE                   Skip the rest of the test CAR-IS-42 and continue by returning (values)
 8: RETEST                     Rerun the test CAR-IS-42
 7: CONTINUE                   Skip the rest of the test TEST-CALLING-TEST and continue by returning (values)
 6: RETEST                     Rerun the test TEST-CALLING-TEST
 5: CONTINUE                   Skip the rest of the test DEMO and continue by returning (values)
 4: RETEST                     Rerun the test DEMO
 3: CONTINUE-WITHOUT-DEBUGGING Turn off debugging for this test session and invoke the first CONTINUE restart
 2: ABORT-TESTING              Abort the entire test session
 1: ABORT                      Return to SLIME's top level.
 0: TERMINATE-THREAD           Terminate this thread (#<THREAD "repl-thread" {C666E89}>)

Backtrace:
  0: (RECORD-FAILURE* STEFIL::FAILED-ASSERTION)
  1: ((LABELS CAR-IS-42))
  2: ((LABELS STEFIL::RUN-TEST-BODY))
  3: ((FLET STEFIL::BODY))
  4: (STEFIL::RUN-TEST-BODY #<test CAR-IS-42> #<CLOSURE (LABELS CAR-IS-42) {D74CED5}> ((X 43)) NIL)
  5: ((LABELS #:BODY2570))
  6: (CAR-IS-42 (43))
  7: ((LABELS TEST-CALLING-TEST))
  8: ((LABELS STEFIL::RUN-TEST-BODY))
  9: ((FLET STEFIL::BODY))
 10: (STEFIL::RUN-TEST-BODY #<test TEST-CALLING-TEST> #<FUNCTION (LABELS TEST-CALLING-TEST) {D11E7E5}> NIL NIL)
 11: ((LABELS #:BODY2575))
 12: (TEST-CALLING-TEST)
 13: ((FLET RUN-CHILD-TESTS))
 14: ((LABELS DEMO))
 15: ((LABELS STEFIL::RUN-TEST-BODY))
 16: ((FLET STEFIL::BODY))
 17: (STEFIL::RUN-TEST-BODY #<test DEMO :tests 2> #<FUNCTION (LABELS DEMO) {CCE1F85}> NIL T)
 18: ((LABELS #:BODY2565))
 19: (DEMO)