Rackunit: test-case makes testing higher-order functions with exception handlers behave oddly

General
1

There's a good chance I'm "holding it wrong," so someone please point out where I've missed things.

I have a test that looks like this:

(define (f g)
  (with-handlers ([exn:fail? (lambda (e)
                               (displayln (exn-message e))
                               e)])
    (g)))
(define result (f (lambda ()
                    (check-equal? 1 2)
                    123)))
(check-equal? result 123))

Output is

--------------------
FAILURE [,bt for context]
name:       check-equal?
location:   string:5:21
actual:     1
expected:   2
--------------------

Now, if I change to test-case:

(test-case "f"
  (define result (f (lambda ()
                      (check-equal? 1 2)
                      123)))
  (check-equal? result 123))

I instead get

--------------------
f
FAILURE [,bt for context]
name:       check-equal?
location:   string:6:1
actual:     (exn:test:check "" #<continuation-mark-set> ...)
expected:   123
--------------------

Notice that the check-equal? failure has been swallowed. I managed to pin this down to an odd interaction between test-case and current-check-around: the former sets the latter to plain-check-around during the execution of the entire test case body, but still invokes current-test-around (presumably this is what enables that early exit behavior when a check fails within a test case). Indeed, only while writing this did I even notice that we have both current-check-around and current-test-around! I (mistakenly) assumed test-case was using current-check-around for a long time because of the comment on check-around:

;; Like default-check-around, except without test logging. This used to be used
;; by test-case, and is currently undocumented. […]
;; Setting (current-check-handler) to `raise` makes this equivalent to
;; plain-check-around.

Anyway, there's an ugly workaround for testing higher-order functions that have their own exception handlers:

(let ([default (current-check-around)])
  (test-case "f"
    (define result (f (lambda ()
                        (parameterize ([current-check-around default])
                          (check-equal? 1 2)
                          123))))
    (check-equal? result 123)))

This does have the side effect that checks within the parameterize do not stop execution of the test case!

(In my real example, I'm going to wrap the parameterize in a function to be called inside the higher-order function, possibly as a macro. Naming it is difficult, though.)