test: is-thrown skips the type symbol so body actually runs

leifericf · claude · leifericf · commit 3c4478d4a427 · 2026-05-20T22:12:16.000+02:00
`(is (thrown? &lt;Type&gt; body))` used to splice (rest expr) into a
do-block. (rest expr) was (&lt;Type&gt; body), so evaluating &lt;Type&gt;
was the FIRST thing the do-block did. When &lt;Type&gt; was unbound
-- which it always is in mino, since there is no exception
class hierarchy -- the lookup itself threw, the catch arm
caught it, and the assertion passed regardless of what `body`
did. Every test that expected a body throw was therefore
silently green even when the body had been refactored to no
longer throw.

Detect the shape at macroexpansion time:

  (thrown? &lt;Type&gt; &lt;body&gt;...)  -- JVM-clojure compatible
  (thrown? &lt;body&gt;)            -- mino's single-arg shorthand

When two or more forms follow `thrown?`, the first is the type
symbol and is dropped before splicing the body; when a single
form follows, it IS the body and is kept. mino's runtime cannot
verify exception class membership, so the type symbol is
documentation-only here; any throw from the body counts as a
pass. Verified by manual reproducer: (is (thrown? Exception
(+ 1 2))) now reports "expected exception but none thrown"
rather than silently passing, and the full 4845-assertion suite
still passes.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,21 @@
 # Changelog
 
+## v0.389.14 — `is-thrown` Correctly Checks the Body, Not the Type Symbol
+
+`(is (thrown? Exception body))` used to silently pass whenever
+the type symbol was unbound: the macro spliced `(rest expr)` --
+which includes both the type symbol and the body -- into a
+`do` block, so evaluating `Exception` itself threw and the
+catch arm registered a pass before the body ever ran. Tests that
+expected the body to throw were therefore green regardless of
+what the body actually did.
+
+The macro now detects the JVM-Clojure shape `(thrown? <type>
+<body>...)` vs the mino single-arg shorthand `(thrown? <body>)`
+by arity and skips the type symbol when present. mino has no
+exception class hierarchy, so the type symbol is treated as
+documentation; any throw from the body counts as a pass.
+
 ## v0.389.13 — Lock-Invariant Assert on Regex Prim Entries
 
 The regex engine in `src/regex/re.c` uses file-static globals
diff --git a/lib/clojure/test.clj b/lib/clojure/test.clj
@@ -55,10 +55,20 @@
   (and (symbol? sym) (= "thrown?" (name sym))))
 
 (defmacro is-thrown [expr msg]
-  `(try
-     (do ~@(rest expr)
-         (assert-fail! (pr-str '~expr) ~msg "expected exception but none thrown"))
-     (catch __e (assert-pass!))))
+  ;; expr matches either of two shapes:
+  ;;   (thrown? <type> <body>...)  -- JVM-clojure compatible
+  ;;   (thrown? <body>)            -- mino single-arg shorthand
+  ;; mino has no exception class hierarchy; the type symbol is
+  ;; documentation-only, so any throw from the body counts as a
+  ;; pass. We detect the JVM shape by arity: 2+ elements after
+  ;; `thrown?` means the first is the type (skip it); 1 element
+  ;; is the body itself.
+  (let [args        (rest expr)
+        body-forms  (if (= 1 (count args)) args (rest args))]
+    `(try
+       (do ~@body-forms
+           (assert-fail! (pr-str '~expr) ~msg "expected exception but none thrown"))
+       (catch __e (assert-pass!)))))
 
 (defmacro is-eq [expr msg]
   (let [gs-exp (gensym) gs-act (gensym)
diff --git a/src/mino.h b/src/mino.h
@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 389
-#define MINO_VERSION_PATCH 13
+#define MINO_VERSION_PATCH 14
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".
