Now it's clear that data-driven (table) testing is easy using map and apply. The next logical evolutionary step for a Lisp-powered framework is Property-Based Testing inspired by QuickCheck.

The Improvement: Add a property macro alongside test and suite.

(property "Reverse of reverse is the original list"
          #:generators (list gen-list)
          #:thunk (lambda (xs)
                    (assert-equal #:expect xs #:got (reverse (reverse xs)))))

Veritas could automatically generate 100 random inputs, execute the assertion, and--if it fails--attempt to "shrink" the failing input to its smallest reproducible form.

Currently, if a user wants to delay evaluation of the #:got argument, they have to use quasiquoting and a specific list structure:

Scheme

#:got `(comp (begin (sleep 4) (+ 10 9)))

While this works, it requires the user to remember quotes and exposes the underlying implementation.

The Improvement: Introduce an implicit macro layer or leverage Scheme native promises (delay and force).

How it looks: You could write macros for assertions that automatically capture #:got as a thunk if wrapped in a custom keyword, or simply support native promises:

Scheme

(assert-equal #:expect 144

#:got (delay (let ((x 12)) (* x x))))

Alternatively, write a macro wrapper so users can just type (lazy-assert-equal ...) or pass an unquoted (comp ...) block that a macro intercepts before evaluation.

Continuous integration tools (GitLab CI, GitHub Actions, Jenkins) can't parse logs natively.

The Improvement: Add a tap-reporter (Test Anything Protocol) or a junit-xml-reporter.

Why it matters: TAP is remarkably easy to implement in plain text, and JUnit XML allows CI dashboards to natively graph test failures, track execution times over time, and highlight exactly which line failed without forcing developers to dig through raw console logs.

Veritas allows #:before and #:after hooks that accept a context (vc). To make these incredibly powerful, ensure that hooks can transform and pass state cleanly into the tests.

The Improvement: If a #:before hook sets up a temporary database connection or a mock file descriptor, it should return that resource wrapped in the context, which is then cleanly passed as an argument directly into the test thunks.

How it looks:

Scheme

(test "Read from temp DB"

#:before (lambda (vc) (setup-mock-db)) ; returns db-conn

(lambda (db-conn) ; test body accepts the fixture

(assert-true (db-active? db-conn))))

assert-match: Integrate Guiles native (ice-9 match) so users can assert that data matches a specific structural shape.