test-->>∃ #:steps n passes test if n > than the number of actual reduction steps for a term. about redex HOT 4 OPEN

This isn't a complete program so I'm not entirely sure what you mean, but here are two examples, one where it finishes in the bound and one where it doesn't and I see the expected results.

#lang racket
(require redex/reduction-semantics)
(define-language L
  (n ::= Z (S n)))

(define-judgment-form L
  #:mode (->* I O)
  [-------------
   (->* (S n) n)])

(test-->>∃ #:steps 6 ->*
           (term (S (S (S (S Z)))))
           (term Z))

(test-->>∃ #:steps 2 ->*
           (term (S (S (S (S Z)))))
           (term Z))

(test-results)

namely:

FAILED /Users/robby/tmp.rkt:15.0
term Z not reachable from (S (S (S (S Z)))) (within 2 steps)
1 test failed (out of 2 total).

from redex.

I should have explained better.

->* is the compatible closure for the language.

My point here is that if the reduction steps are less than the mentioned steps in #:steps, even then
the tests pass.
I understand that it is the default behavior of the tests.

However, my thought was if we could have tests passing when the reduction steps
are exactly equal to #:steps n, where n is the precise number.

from redex.

Can you supply some working code to better illustrate what you mean, please?

from redex.

The steps argument is more of an upper-bound to avoid running for a long time than it is to count an exact number of steps. One complexity of adding one is that these relations don't necessarily have exactly one way to reduce each term so we'd have to define something that makes sense for such relations too.

from redex.