simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Source the conformance corpus from JVM Clojure; retire the prelude gate

Browse source 
corpus.edn :expected is now the value reference JVM Clojure produces, set by the
new test/conformance/regen-corpus.clj (one JVM process, per-row thread watchdog).
167 rows moved to the JVM value: ratios (/ 1 2)=>1/2, doubles (double 3)=>3.0,
shared-heap concurrency (the future/pmap/agent cases), clojure.math doubles. The
JVM is the spec; jolt is measured against it.

known-divergences.edn shrinks to the rows whose JVM value is an opaque host object
that can't round-trip to source (Java arrays, transients, atoms, beans, proxies,
chunks all print as #object[..@addr]) plus (fn* foo) and a few racy concurrency
cases (:flaky). The zero-janet gate's allowlist becomes the set of host gaps vs the
JVM spec (no Class/array/BigDecimal, :jolt reader, jolt's own printing).

Math/clojure.math sqrt/pow/floor/trig now return doubles (Chez returns exact for
exact args, e.g. (sqrt 9)=>3); JVM always returns a double.

extract-corpus.janet no longer writes corpus.edn unless asked (the test runner
imported it and was silently overwriting the JVM corpus with the spec sources'
placeholder answers). The prelude parity gate is deleted — the zero-janet spine +
certify.clj are the oracles.

zero-janet 2678 (0 new divergences), certify 0 new / 0 stale, emit-test 330/330.
This commit is contained in:
Yogthos 2026-06-21 01:45:04 -04:00
parent 467ad75ff7
commit da775802d6
13 changed files with 435 additions and 823 deletions
Download patch file Download diff file Expand all files Collapse all files

10
host/chez/converters.ss
View file

@ -1,9 +1,7 @@
;; converters + string ops (jolt-t6cr) — host-coupled seed natives the Chez host ;; converters + string ops — host-coupled natives def-var!'d into clojure.core,
;; must provide; def-var!'d into clojure.core, resolved in prelude mode. Loaded ;; resolved in prelude mode. Loaded last (after jolt-pr-str), since `str` reuses
;; last (after jolt-pr-str), since `str` reuses the printer. Semantics match the ;; the printer. int/long truncate toward zero to an exact integer; compare returns
;; Janet seed (core_print.janet str-render-one, core_io.janet core-compare, ;; an exact -1/0/1; double yields a flonum.
;; core_refs.janet int/double). jolt is all-flonum, so numeric results are
;; flonums (int truncates toward zero, compare returns -1.0/0.0/1.0).
;; str: nil -> "", string raw, char bare (not \c), regex -> raw source, else the ;; str: nil -> "", string raw, char bare (not \c), regex -> raw source, else the
;; printer (which renders collections with readable elements). ;; printer (which renders collections with readable elements).

12
host/chez/dynamic-vars.ss
View file

@ -1,11 +1,9 @@
;; dynamic vars (jolt-9ls5) — the handful of clojure.core dynamic vars the seed ;; dynamic vars — the handful of clojure.core dynamic vars that aren't emitted into
;; binds natively (src/jolt/core.janet) that aren't emitted into the prelude, so ;; the prelude. These two are plain constants; *ns* (a namespace object) needs a
;; they var-deref to nil on Chez. These two are plain constants; *ns* (a namespace ;; value type with get-see-through and map?=false and is tracked separately. Loaded
;; object) needs a value type with get-see-through and map?=false and is tracked ;; from rt.ss after the value model + def-var!.
;; separately. Loaded from rt.ss after the value model + def-var!.
;; *clojure-version* — a jolt map {:major 1 :minor 11 :incremental 0 :qualifier nil} ;; *clojure-version* — a map {:major 1 :minor 11 :incremental 0 :qualifier nil}.
;; (jolt is all-flonum, so the numbers are flonums).
(def-var! "clojure.core" "*clojure-version*" (def-var! "clojure.core" "*clojure-version*"
(jolt-hash-map (keyword #f "major") 1 (jolt-hash-map (keyword #f "major") 1
(keyword #f "minor") 11 (keyword #f "minor") 11

32
host/chez/host-static.ss
View file

@ -122,22 +122,26 @@
(define (char-code c) (if (char? c) (char->integer c) (jnum->exact c))) (define (char-code c) (if (char? c) (char->integer c) (jnum->exact c)))
;; ---- java.lang statics ------------------------------------------------------ ;; ---- java.lang statics ------------------------------------------------------
;; java.lang.Math: sqrt/pow/floor/ceil/trig/log/exp always return a DOUBLE on the
;; JVM (Chez's sqrt/expt return EXACT for exact args, e.g. (sqrt 9) -> 3), so coerce
;; to flonum. round -> long (exact); abs/max/min preserve the argument's type.
(define (->dbl x) (exact->inexact x))
(register-class-statics! "Math" (register-class-statics! "Math"
(list (cons "sqrt" (lambda (x) (->num (sqrt x)))) (list (cons "sqrt" (lambda (x) (->dbl (sqrt x))))
(cons "pow" (lambda (a b) (->num (expt a b)))) (cons "pow" (lambda (a b) (->dbl (expt a b))))
(cons "floor" (lambda (x) (->num (floor x)))) (cons "floor" (lambda (x) (->dbl (floor x))))
(cons "ceil" (lambda (x) (->num (ceiling x)))) (cons "ceil" (lambda (x) (->dbl (ceiling x))))
(cons "round" (lambda (x) (->num (round x)))) (cons "round" (lambda (x) (exact (floor (+ x 1/2))))) ; JVM round-half-up -> long
(cons "abs" (lambda (x) (->num (abs x)))) (cons "abs" (lambda (x) (abs x)))
(cons "sin" (lambda (x) (->num (sin x)))) (cons "cos" (lambda (x) (->num (cos x)))) (cons "sin" (lambda (x) (->dbl (sin x)))) (cons "cos" (lambda (x) (->dbl (cos x))))
(cons "tan" (lambda (x) (->num (tan x)))) (cons "asin" (lambda (x) (->num (asin x)))) (cons "tan" (lambda (x) (->dbl (tan x)))) (cons "asin" (lambda (x) (->dbl (asin x))))
(cons "acos" (lambda (x) (->num (acos x)))) (cons "atan" (lambda (x) (->num (atan x)))) (cons "acos" (lambda (x) (->dbl (acos x)))) (cons "atan" (lambda (x) (->dbl (atan x))))
(cons "log" (lambda (x) (->num (log x)))) (cons "log10" (lambda (x) (->num (/ (log x) (log 10))))) (cons "log" (lambda (x) (->dbl (log x)))) (cons "log10" (lambda (x) (->dbl (/ (log x) (log 10)))))
(cons "exp" (lambda (x) (->num (exp x)))) (cons "exp" (lambda (x) (->dbl (exp x))))
(cons "max" (lambda (a b) (->num (if (> a b) a b)))) (cons "min" (lambda (a b) (->num (if (< a b) a b)))) (cons "max" (lambda (a b) (if (> a b) a b))) (cons "min" (lambda (a b) (if (< a b) a b)))
(cons "signum" (lambda (x) (cond ((< x 0) -1.0) ((> x 0) 1.0) (else 0.0)))) (cons "signum" (lambda (x) (cond ((< x 0) -1.0) ((> x 0) 1.0) (else 0.0))))
(cons "PI" (->num (* 4 (atan 1)))) (cons "E" (->num (exp 1))) (cons "PI" (->dbl (* 4 (atan 1)))) (cons "E" (->dbl (exp 1)))
(cons "random" (lambda args (->num (random 1.0)))))) (cons "random" (lambda args (random 1.0)))))
;; Thread: real OS threads back futures/promises (jolt-byjr), so sleep genuinely ;; Thread: real OS threads back futures/promises (jolt-byjr), so sleep genuinely
;; parks the calling thread for `ms` milliseconds (a worker sleeping doesn't block ;; parks the calling thread for `ms` milliseconds (a worker sleeping doesn't block

40
host/chez/math.ss
View file

@ -31,28 +31,32 @@
(define (jolt-math-floor-div a b) (floor (/ a b))) (define (jolt-math-floor-div a b) (floor (/ a b)))
(define (jolt-math-floor-mod a b) (- a (* b (floor (/ a b))))) (define (jolt-math-floor-mod a b) (- a (* b (floor (/ a b)))))
(def-var! "clojure.math" "sqrt" sqrt) ;; clojure.math fns always return a DOUBLE; Chez's sqrt/expt/sin/floor/... return
;; EXACT for exact args ((sqrt 9) -> 3, (sin 0) -> 0), so coerce.
(define (m1 f) (lambda (x) (exact->inexact (f x))))
(define (m2 f) (lambda (a b) (exact->inexact (f a b))))
(def-var! "clojure.math" "sqrt" (m1 sqrt))
(def-var! "clojure.math" "cbrt" jolt-math-cbrt) (def-var! "clojure.math" "cbrt" jolt-math-cbrt)
(def-var! "clojure.math" "pow" expt) (def-var! "clojure.math" "pow" (m2 expt))
(def-var! "clojure.math" "exp" exp) (def-var! "clojure.math" "exp" (m1 exp))
(def-var! "clojure.math" "expm1" (lambda (x) (- (exp x) 1.0))) (def-var! "clojure.math" "expm1" (lambda (x) (- (exp x) 1.0)))
(def-var! "clojure.math" "log" log) (def-var! "clojure.math" "log" (m1 log))
(def-var! "clojure.math" "log10" (lambda (x) (log x 10.0))) (def-var! "clojure.math" "log10" (lambda (x) (exact->inexact (log x 10.0))))
(def-var! "clojure.math" "log1p" (lambda (x) (log (+ 1.0 x)))) (def-var! "clojure.math" "log1p" (lambda (x) (log (+ 1.0 x))))
(def-var! "clojure.math" "sin" sin) (def-var! "clojure.math" "sin" (m1 sin))
(def-var! "clojure.math" "cos" cos) (def-var! "clojure.math" "cos" (m1 cos))
(def-var! "clojure.math" "tan" tan) (def-var! "clojure.math" "tan" (m1 tan))
(def-var! "clojure.math" "asin" asin) (def-var! "clojure.math" "asin" (m1 asin))
(def-var! "clojure.math" "acos" acos) (def-var! "clojure.math" "acos" (m1 acos))
(def-var! "clojure.math" "atan" atan) (def-var! "clojure.math" "atan" (m1 atan))
;; clojure.math/atan2 is atan2(y, x); Chez's 2-arg atan is (atan y x). ;; clojure.math/atan2 is atan2(y, x); Chez's 2-arg atan is (atan y x).
(def-var! "clojure.math" "atan2" (lambda (y x) (atan y x))) (def-var! "clojure.math" "atan2" (lambda (y x) (exact->inexact (atan y x))))
(def-var! "clojure.math" "sinh" sinh) (def-var! "clojure.math" "sinh" (m1 sinh))
(def-var! "clojure.math" "cosh" cosh) (def-var! "clojure.math" "cosh" (m1 cosh))
(def-var! "clojure.math" "tanh" tanh) (def-var! "clojure.math" "tanh" (m1 tanh))
(def-var! "clojure.math" "floor" floor) (def-var! "clojure.math" "floor" (m1 floor))
(def-var! "clojure.math" "ceil" ceiling) (def-var! "clojure.math" "ceil" (m1 ceiling))
(def-var! "clojure.math" "rint" round) (def-var! "clojure.math" "rint" (m1 round))
(def-var! "clojure.math" "round" jolt-math-round) (def-var! "clojure.math" "round" jolt-math-round)
(def-var! "clojure.math" "signum" jolt-math-signum) (def-var! "clojure.math" "signum" jolt-math-signum)
(def-var! "clojure.math" "to-degrees" jolt-math-to-degrees) (def-var! "clojure.math" "to-degrees" jolt-math-to-degrees)

8
host/chez/reader.ss
View file

@ -73,11 +73,9 @@
;; jolt models EVERY number as a double (emit-const lowers integer literals to ;; jolt models EVERY number as a double (emit-const lowers integer literals to
;; flonums too), so the reader coerces every parsed number to inexact — else a ;; flonums too), so the reader coerces every parsed number to inexact — else a
;; read int (exact) is not jolt= to a source int literal (flonum). ;; read int (exact) is not jolt= to a source int literal (flonum).
;; Preserve exactness for the Chez numeric tower (JVM parity): integer literals ;; Numeric tower (JVM parity): integer literals read as exact integers (= Long/
;; read as exact integers (= Long/BigInt, arbitrary precision), a/b ratios as ;; BigInt, arbitrary precision), a/b ratios as exact rationals (= Ratio), and
;; exact rationals (= Ratio), and decimal/exponent literals as flonums (= double). ;; decimal/exponent literals as flonums (= double).
;; Only the zero-Janet path (this reader) carries exactness through to runtime;
;; the Janet-reader prelude path stays all-flonum (Janet has only doubles).
(define (rdr-try-number tok) (define (rdr-try-number tok)
(rdr-try-number-raw tok)) (rdr-try-number-raw tok))

334
test/chez/corpus.edn
View file

@ -273,7 +273,7 @@
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "fnil only first 3" :expected "[:a :b :c nil]" :actual "((fnil vector :a :b :c) nil nil nil nil)"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "fnil only first 3" :expected "[:a :b :c nil]" :actual "((fnil vector :a :b :c) nil nil nil nil)"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "fnil in update" :expected "{:k 1}" :actual "(update {} :k (fnil inc 0))"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "fnil in update" :expected "{:k 1}" :actual "(update {} :k (fnil inc 0))"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "clojure-version" :expected "true" :actual "(string? (clojure-version))"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "clojure-version" :expected "true" :actual "(string? (clojure-version))"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "bigdec" :expected "3" :actual "(bigdec 3)"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "bigdec" :expected "3M" :actual "(bigdec 3)"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "numerator throws" :expected :throws :actual "(numerator 1)"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "numerator throws" :expected :throws :actual "(numerator 1)"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "denominator throws" :expected :throws :actual "(denominator 1)"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "denominator throws" :expected :throws :actual "(denominator 1)"}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "supers empty set" :expected "#{}" :actual "(supers 1)"} {:suite "clojure.core / leaf batch (complement fnil munge etc.)" :label "supers empty set" :expected "#{}" :actual "(supers 1)"}
@ -290,18 +290,18 @@
{:suite "clojure.core / leaf batch 2" :label "select-keys" :expected "{:a 1}" :actual "(select-keys {:a 1 :b 2} [:a])"} {:suite "clojure.core / leaf batch 2" :label "select-keys" :expected "{:a 1}" :actual "(select-keys {:a 1 :b 2} [:a])"}
{:suite "clojure.core / leaf batch 2" :label "select-keys nil val" :expected "{:a nil}" :actual "(select-keys {:a nil :b 2} [:a])"} {:suite "clojure.core / leaf batch 2" :label "select-keys nil val" :expected "{:a nil}" :actual "(select-keys {:a nil :b 2} [:a])"}
{:suite "clojure.core / leaf batch 2" :label "select-keys missing" :expected "{}" :actual "(select-keys {:a 1} [:z])"} {:suite "clojure.core / leaf batch 2" :label "select-keys missing" :expected "{}" :actual "(select-keys {:a 1} [:z])"}
{:suite "clojure.core / leaf batch 2" :label "zipmap" :expected "{:a 1 :b 2}" :actual "(zipmap [:a :b] [1 2])"} {:suite "clojure.core / leaf batch 2" :label "zipmap" :expected "{:a 1, :b 2}" :actual "(zipmap [:a :b] [1 2])"}
{:suite "clojure.core / leaf batch 2" :label "zipmap uneven" :expected "{:a 1}" :actual "(zipmap [:a :b] [1])"} {:suite "clojure.core / leaf batch 2" :label "zipmap uneven" :expected "{:a 1}" :actual "(zipmap [:a :b] [1])"}
{:suite "clojure.core / leaf batch 2" :label "zipmap nil val" :expected "{:a nil}" :actual "(zipmap [:a] [nil])"} {:suite "clojure.core / leaf batch 2" :label "zipmap nil val" :expected "{:a nil}" :actual "(zipmap [:a] [nil])"}
{:suite "clojure.core / leaf batch 2" :label "merge" :expected "{:a 1 :b 2}" :actual "(merge {:a 1} {:b 2})"} {:suite "clojure.core / leaf batch 2" :label "merge" :expected "{:a 1, :b 2}" :actual "(merge {:a 1} {:b 2})"}
{:suite "clojure.core / leaf batch 2" :label "merge later wins" :expected "{:a 2}" :actual "(merge {:a 1} {:a 2})"} {:suite "clojure.core / leaf batch 2" :label "merge later wins" :expected "{:a 2}" :actual "(merge {:a 1} {:a 2})"}
{:suite "clojure.core / leaf batch 2" :label "merge nil arg" :expected "{:a 1}" :actual "(merge {:a 1} nil)"} {:suite "clojure.core / leaf batch 2" :label "merge nil arg" :expected "{:a 1}" :actual "(merge {:a 1} nil)"}
{:suite "clojure.core / leaf batch 2" :label "merge nil first" :expected "{:a 1}" :actual "(merge nil {:a 1})"} {:suite "clojure.core / leaf batch 2" :label "merge nil first" :expected "{:a 1}" :actual "(merge nil {:a 1})"}
{:suite "clojure.core / leaf batch 2" :label "merge all nil" :expected "nil" :actual "(merge nil nil)"} {:suite "clojure.core / leaf batch 2" :label "merge all nil" :expected "nil" :actual "(merge nil nil)"}
{:suite "clojure.core / leaf batch 2" :label "merge empty" :expected "nil" :actual "(merge)"} {:suite "clojure.core / leaf batch 2" :label "merge empty" :expected "nil" :actual "(merge)"}
{:suite "clojure.core / leaf batch 2" :label "merge entry pair" :expected "{:a 1 :b 2}" :actual "(merge {:a 1} [:b 2])"} {:suite "clojure.core / leaf batch 2" :label "merge entry pair" :expected "{:a 1, :b 2}" :actual "(merge {:a 1} [:b 2])"}
{:suite "clojure.core / leaf batch 2" :label "merge-with" :expected "{:a 3}" :actual "(merge-with + {:a 1} {:a 2})"} {:suite "clojure.core / leaf batch 2" :label "merge-with" :expected "{:a 3}" :actual "(merge-with + {:a 1} {:a 2})"}
{:suite "clojure.core / leaf batch 2" :label "merge-with disjoint" :expected "{:a 1 :b 2}" :actual "(merge-with + {:a 1} {:b 2})"} {:suite "clojure.core / leaf batch 2" :label "merge-with disjoint" :expected "{:a 1, :b 2}" :actual "(merge-with + {:a 1} {:b 2})"}
{:suite "clojure.core / leaf batch 2" :label "merge-with nil-val present" :expected "{:a 1}" :actual "(merge-with (fn [a b] (or a b)) {:a nil} {:a 1})"} {:suite "clojure.core / leaf batch 2" :label "merge-with nil-val present" :expected "{:a 1}" :actual "(merge-with (fn [a b] (or a b)) {:a nil} {:a 1})"}
{:suite "clojure.core / leaf batch 2" :label "get-in" :expected "1" :actual "(get-in {:a {:b 1}} [:a :b])"} {:suite "clojure.core / leaf batch 2" :label "get-in" :expected "1" :actual "(get-in {:a {:b 1}} [:a :b])"}
{:suite "clojure.core / leaf batch 2" :label "get-in missing" :expected ":nf" :actual "(get-in {:a 1} [:z :y] :nf)"} {:suite "clojure.core / leaf batch 2" :label "get-in missing" :expected ":nf" :actual "(get-in {:a 1} [:z :y] :nf)"}
@ -320,42 +320,42 @@
{:suite "clojure.core / leaf batch 2" :label "min" :expected "1" :actual "(min 3 1 2)"} {:suite "clojure.core / leaf batch 2" :label "min" :expected "1" :actual "(min 3 1 2)"}
{:suite "clojure.core / leaf batch 2" :label "max single" :expected "5" :actual "(max 5)"} {:suite "clojure.core / leaf batch 2" :label "max single" :expected "5" :actual "(max 5)"}
{:suite "clojure.core / leaf batch 2" :label "max non-number throws" :expected :throws :actual "(max 1 :a)"} {:suite "clojure.core / leaf batch 2" :label "max non-number throws" :expected :throws :actual "(max 1 :a)"}
{:suite "clojure.core / leaf batch 2" :label "reverse" :expected "(quote (3 2 1))" :actual "(reverse [1 2 3])"} {:suite "clojure.core / leaf batch 2" :label "reverse" :expected "[3 2 1]" :actual "(reverse [1 2 3])"}
{:suite "clojure.core / leaf batch 2" :label "reverse empty" :expected "()" :actual "(reverse nil)"} {:suite "clojure.core / leaf batch 2" :label "reverse empty" :expected "[]" :actual "(reverse nil)"}
{:suite "clojure.core / leaf batch 2" :label "conj nil onto map" :expected "{:a 1}" :actual "(conj {:a 1} nil)"} {:suite "clojure.core / leaf batch 2" :label "conj nil onto map" :expected "{:a 1}" :actual "(conj {:a 1} nil)"}
{:suite "clojure.core / leaf batch 3" :label "empty vector" :expected "[]" :actual "(empty [1 2])"} {:suite "clojure.core / leaf batch 3" :label "empty vector" :expected "[]" :actual "(empty [1 2])"}
{:suite "clojure.core / leaf batch 3" :label "empty list" :expected "()" :actual "(empty (list 1))"} {:suite "clojure.core / leaf batch 3" :label "empty list" :expected "[]" :actual "(empty (list 1))"}
{:suite "clojure.core / leaf batch 3" :label "empty map" :expected "{}" :actual "(empty {:a 1})"} {:suite "clojure.core / leaf batch 3" :label "empty map" :expected "{}" :actual "(empty {:a 1})"}
{:suite "clojure.core / leaf batch 3" :label "empty set" :expected "#{}" :actual "(empty #{1})"} {:suite "clojure.core / leaf batch 3" :label "empty set" :expected "#{}" :actual "(empty #{1})"}
{:suite "clojure.core / leaf batch 3" :label "empty nil" :expected "nil" :actual "(empty nil)"} {:suite "clojure.core / leaf batch 3" :label "empty nil" :expected "nil" :actual "(empty nil)"}
{:suite "clojure.core / leaf batch 3" :label "empty string" :expected "nil" :actual "(empty \"abc\")"} {:suite "clojure.core / leaf batch 3" :label "empty string" :expected "nil" :actual "(empty \"abc\")"}
{:suite "clojure.core / leaf batch 3" :label "empty lazy is ()" :expected "()" :actual "(empty (map inc [1 2]))"} {:suite "clojure.core / leaf batch 3" :label "empty lazy is ()" :expected "[]" :actual "(empty (map inc [1 2]))"}
{:suite "clojure.core / leaf batch 3" :label "empty sorted keeps cmp" :expected "[3 1]" :actual "(vec (seq (into (empty (sorted-set-by > 1 2)) [1 3])))"} {:suite "clojure.core / leaf batch 3" :label "empty sorted keeps cmp" :expected "[3 1]" :actual "(vec (seq (into (empty (sorted-set-by > 1 2)) [1 3])))"}
{:suite "clojure.core / leaf batch 3" :label "assoc-in" :expected "{:a {:b 1}}" :actual "(assoc-in {} [:a :b] 1)"} {:suite "clojure.core / leaf batch 3" :label "assoc-in" :expected "{:a {:b 1}}" :actual "(assoc-in {} [:a :b] 1)"}
{:suite "clojure.core / leaf batch 3" :label "assoc-in deep" :expected "{:a {:b {:c 2}}}" :actual "(assoc-in {:a {:b {:c 1}}} [:a :b :c] 2)"} {:suite "clojure.core / leaf batch 3" :label "assoc-in deep" :expected "{:a {:b {:c 2}}}" :actual "(assoc-in {:a {:b {:c 1}}} [:a :b :c] 2)"}
{:suite "clojure.core / leaf batch 3" :label "assoc-in keeps siblings" :expected "{:a {:b 1 :c 2}}" :actual "(assoc-in {:a {:b 1}} [:a :c] 2)"} {:suite "clojure.core / leaf batch 3" :label "assoc-in keeps siblings" :expected "{:a {:b 1, :c 2}}" :actual "(assoc-in {:a {:b 1}} [:a :c] 2)"}
{:suite "clojure.core / leaf batch 3" :label "assoc-in vector idx" :expected "[1 9]" :actual "(assoc-in [1 2] [1] 9)"} {:suite "clojure.core / leaf batch 3" :label "assoc-in vector idx" :expected "[1 9]" :actual "(assoc-in [1 2] [1] 9)"}
{:suite "clojure.core / leaf batch 3" :label "assoc-in nested vec" :expected "[{:a 9}]" :actual "(assoc-in [{:a 1}] [0 :a] 9)"} {:suite "clojure.core / leaf batch 3" :label "assoc-in nested vec" :expected "[{:a 9}]" :actual "(assoc-in [{:a 1}] [0 :a] 9)"}
{:suite "clojure.core / leaf batch 3" :label "update-in" :expected "{:a {:b 2}}" :actual "(update-in {:a {:b 1}} [:a :b] inc)"} {:suite "clojure.core / leaf batch 3" :label "update-in" :expected "{:a {:b 2}}" :actual "(update-in {:a {:b 1}} [:a :b] inc)"}
{:suite "clojure.core / leaf batch 3" :label "update-in extra args" :expected "{:a {:b 111}}" :actual "(update-in {:a {:b 1}} [:a :b] + 10 100)"} {:suite "clojure.core / leaf batch 3" :label "update-in extra args" :expected "{:a {:b 111}}" :actual "(update-in {:a {:b 1}} [:a :b] + 10 100)"}
{:suite "clojure.core / leaf batch 3" :label "update-in fnil" :expected "{:a {:b 1}}" :actual "(update-in {} [:a :b] (fnil inc 0))"} {:suite "clojure.core / leaf batch 3" :label "update-in fnil" :expected "{:a {:b 1}}" :actual "(update-in {} [:a :b] (fnil inc 0))"}
{:suite "clojure.core / leaf batch 3" :label "update-in single key" :expected "{:a 2}" :actual "(update-in {:a 1} [:a] inc)"} {:suite "clojure.core / leaf batch 3" :label "update-in single key" :expected "{:a 2}" :actual "(update-in {:a 1} [:a] inc)"}
{:suite "clojure.core / leaf batch 3" :label "interpose" :expected "(quote (1 :s 2 :s 3))" :actual "(interpose :s [1 2 3])"} {:suite "clojure.core / leaf batch 3" :label "interpose" :expected "[1 :s 2 :s 3]" :actual "(interpose :s [1 2 3])"}
{:suite "clojure.core / leaf batch 3" :label "interpose empty" :expected "()" :actual "(interpose :s [])"} {:suite "clojure.core / leaf batch 3" :label "interpose empty" :expected "[]" :actual "(interpose :s [])"}
{:suite "clojure.core / leaf batch 3" :label "interpose one" :expected "(quote (1))" :actual "(interpose :s [1])"} {:suite "clojure.core / leaf batch 3" :label "interpose one" :expected "[1]" :actual "(interpose :s [1])"}
{:suite "clojure.core / leaf batch 3" :label "interpose is lazy" :expected "(quote (0 :s 1))" :actual "(take 3 (interpose :s (range)))"} {:suite "clojure.core / leaf batch 3" :label "interpose is lazy" :expected "[0 :s 1]" :actual "(take 3 (interpose :s (range)))"}
{:suite "clojure.core / leaf batch 3" :label "interpose xform" :expected "[\"a\" \",\" \"b\"]" :actual "(vec (sequence (interpose \",\") [\"a\" \"b\"]))"} {:suite "clojure.core / leaf batch 3" :label "interpose xform" :expected "[\"a\" \",\" \"b\"]" :actual "(vec (sequence (interpose \",\") [\"a\" \"b\"]))"}
{:suite "clojure.core / leaf batch 3" :label "take-nth" :expected "(quote (1 3 5))" :actual "(take-nth 2 [1 2 3 4 5 6])"} {:suite "clojure.core / leaf batch 3" :label "take-nth" :expected "[1 3 5]" :actual "(take-nth 2 [1 2 3 4 5 6])"}
{:suite "clojure.core / leaf batch 3" :label "take-nth lazy" :expected "(quote (0 3 6))" :actual "(take 3 (take-nth 3 (range)))"} {:suite "clojure.core / leaf batch 3" :label "take-nth lazy" :expected "[0 3 6]" :actual "(take 3 (take-nth 3 (range)))"}
{:suite "clojure.core / leaf batch 3" :label "take-nth xform" :expected "[1 3 5]" :actual "(vec (sequence (take-nth 2) [1 2 3 4 5 6]))"} {:suite "clojure.core / leaf batch 3" :label "take-nth xform" :expected "[1 3 5]" :actual "(vec (sequence (take-nth 2) [1 2 3 4 5 6]))"}
{:suite "clojure.core / leaf batch 3" :label "take-nth into" :expected "[1 4]" :actual "(into [] (take-nth 3) [1 2 3 4 5])"} {:suite "clojure.core / leaf batch 3" :label "take-nth into" :expected "[1 4]" :actual "(into [] (take-nth 3) [1 2 3 4 5])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by keyfn" :expected "[[1 :b] [2 :a]]" :actual "(sort-by first [[2 :a] [1 :b]])"} {:suite "clojure.core / leaf batch 4" :label "sort-by keyfn" :expected "[[1 :b] [2 :a]]" :actual "(sort-by first [[2 :a] [1 :b]])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by string keys" :expected "(quote (\"a\" \"bb\" \"ccc\"))" :actual "(sort-by count [\"ccc\" \"a\" \"bb\"])"} {:suite "clojure.core / leaf batch 4" :label "sort-by string keys" :expected "[\"a\" \"bb\" \"ccc\"]" :actual "(sort-by count [\"ccc\" \"a\" \"bb\"])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by comparator" :expected "[3 2 1]" :actual "(sort-by identity > [1 3 2])"} {:suite "clojure.core / leaf batch 4" :label "sort-by comparator" :expected "[3 2 1]" :actual "(sort-by identity > [1 3 2])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by 3way cmp" :expected "[3 2 1]" :actual "(sort-by identity (fn [a b] (- b a)) [1 3 2])"} {:suite "clojure.core / leaf batch 4" :label "sort-by 3way cmp" :expected "[3 2 1]" :actual "(sort-by identity (fn [a b] (- b a)) [1 3 2])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by mixed nil" :expected "[nil 1 2]" :actual "(sort-by identity [2 nil 1])"} {:suite "clojure.core / leaf batch 4" :label "sort-by mixed nil" :expected "[nil 1 2]" :actual "(sort-by identity [2 nil 1])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by empty" :expected "()" :actual "(sort-by first [])"} {:suite "clojure.core / leaf batch 4" :label "sort-by empty" :expected "[]" :actual "(sort-by first [])"}
{:suite "clojure.core / leaf batch 4" :label "sort-by nil coll" :expected "()" :actual "(sort-by first nil)"} {:suite "clojure.core / leaf batch 4" :label "sort-by nil coll" :expected "[]" :actual "(sort-by first nil)"}
{:suite "clojure.core / leaf batch 4" :label "rand-int range" :expected "true" :actual "(every? (fn [_] (let [r (rand-int 5)] (and (int? r) (<= 0 r 4)))) (range 50))"} {:suite "clojure.core / leaf batch 4" :label "rand-int range" :expected "true" :actual "(every? (fn [_] (let [r (rand-int 5)] (and (int? r) (<= 0 r 4)))) (range 50))"}
{:suite "clojure.core / leaf batch 4" :label "rand-int zero" :expected "0" :actual "(rand-int 1)"} {:suite "clojure.core / leaf batch 4" :label "rand-int zero" :expected "0" :actual "(rand-int 1)"}
{:suite "clojure.core / leaf batch 4" :label "shuffle is permutation" :expected "true" :actual "(= (sort (shuffle [5 3 1 4 2])) [1 2 3 4 5])"} {:suite "clojure.core / leaf batch 4" :label "shuffle is permutation" :expected "true" :actual "(= (sort (shuffle [5 3 1 4 2])) [1 2 3 4 5])"}
@ -373,7 +373,7 @@
{:suite "clojure.core / leaf batch 4" :label "char-name none" :expected "nil" :actual "(char-name-string \\a)"} {:suite "clojure.core / leaf batch 4" :label "char-name none" :expected "nil" :actual "(char-name-string \\a)"}
{:suite "functions / recur into variadic arity" :label "counts rest via recur" :expected "3" :actual "((fn cnt [acc & xs] (if (seq xs) (recur (inc acc) (rest xs)) acc)) 0 :a :b :c)"} {:suite "functions / recur into variadic arity" :label "counts rest via recur" :expected "3" :actual "((fn cnt [acc & xs] (if (seq xs) (recur (inc acc) (rest xs)) acc)) 0 :a :b :c)"}
{:suite "functions / recur into variadic arity" :label "zero-fixed variadic" :expected "4" :actual "((fn f [& xs] (if (< (count xs) 4) (recur (cons :x xs)) (count xs))) :a)"} {:suite "functions / recur into variadic arity" :label "zero-fixed variadic" :expected "4" :actual "((fn f [& xs] (if (< (count xs) 4) (recur (cons :x xs)) (count xs))) :a)"}
{:suite "functions / recur into variadic arity" :label "rest empties to nil" :expected "(quote (:done))" :actual "((fn f [& xs] (if xs (recur (next xs)) (list :done))) 1 2)"} {:suite "functions / recur into variadic arity" :label "rest empties to nil" :expected "[:done]" :actual "((fn f [& xs] (if xs (recur (next xs)) (list :done))) 1 2)"}
{:suite "functions / recur into variadic arity" :label "multi-arity variadic recur" :expected "6" :actual "((fn ma ([a] a) ([a & xs] (if (seq xs) (recur (+ a (first xs)) (rest xs)) a))) 1 2 3)"} {:suite "functions / recur into variadic arity" :label "multi-arity variadic recur" :expected "6" :actual "((fn ma ([a] a) ([a & xs] (if (seq xs) (recur (+ a (first xs)) (rest xs)) a))) 1 2 3)"}
{:suite "functions / recur into variadic arity" :label "recur passes nil rest" :expected ":empty" :actual "((fn f [acc & xs] (if (seq xs) (recur acc (rest xs)) :empty)) 0 1)"} {:suite "functions / recur into variadic arity" :label "recur passes nil rest" :expected ":empty" :actual "((fn f [acc & xs] (if (seq xs) (recur acc (rest xs)) :empty)) 0 1)"}
{:suite "functions / recur into variadic arity" :label "fixed-arity recur untouched" :expected "10" :actual "((fn f [n acc] (if (pos? n) (recur (dec n) (+ acc 2)) acc)) 5 0)"} {:suite "functions / recur into variadic arity" :label "fixed-arity recur untouched" :expected "10" :actual "((fn f [n acc] (if (pos? n) (recur (dec n) (+ acc 2)) acc)) 5 0)"}
@ -381,8 +381,8 @@
{:suite "functions / empty rest arg is nil" :label "after fixed" :expected ":nil" :actual "((fn [a & r] (if r :truthy :nil)) 1)"} {:suite "functions / empty rest arg is nil" :label "after fixed" :expected ":nil" :actual "((fn [a & r] (if r :truthy :nil)) 1)"}
{:suite "functions / empty rest arg is nil" :label "via apply" :expected ":nil" :actual "(apply (fn [& r] (if r :truthy :nil)) [])"} {:suite "functions / empty rest arg is nil" :label "via apply" :expected ":nil" :actual "(apply (fn [& r] (if r :truthy :nil)) [])"}
{:suite "functions / empty rest arg is nil" :label "defn no args" :expected ":nil" :actual "(do (defn er-f [& r] (if r :truthy :nil)) (er-f))"} {:suite "functions / empty rest arg is nil" :label "defn no args" :expected ":nil" :actual "(do (defn er-f [& r] (if r :truthy :nil)) (er-f))"}
{:suite "functions / empty rest arg is nil" :label "non-empty unchanged" :expected "'(1 2)" :actual "((fn [& r] r) 1 2)"} {:suite "functions / empty rest arg is nil" :label "non-empty unchanged" :expected "[1 2]" :actual "((fn [& r] r) 1 2)"}
{:suite "functions / empty rest arg is nil" :label "one extra" :expected "'(2)" :actual "((fn [a & r] r) 1 2)"} {:suite "functions / empty rest arg is nil" :label "one extra" :expected "[2]" :actual "((fn [a & r] r) 1 2)"}
{:suite "functions / empty rest arg is nil" :label "rest destructure with no args" :expected ":nil" :actual "((fn [& [a]] (if a :truthy :nil)))"} {:suite "functions / empty rest arg is nil" :label "rest destructure with no args" :expected ":nil" :actual "((fn [& [a]] (if a :truthy :nil)))"}
{:suite "functions / arity enforcement" :label "fixed extra args" :expected :throws :actual "((fn [x] x) 1 2)"} {:suite "functions / arity enforcement" :label "fixed extra args" :expected :throws :actual "((fn [x] x) 1 2)"}
{:suite "functions / arity enforcement" :label "fixed missing args" :expected :throws :actual "((fn [x y] x) 1)"} {:suite "functions / arity enforcement" :label "fixed missing args" :expected :throws :actual "((fn [x y] x) 1)"}
@ -393,7 +393,7 @@
{:suite "functions / arity enforcement" :label "through update" :expected :throws :actual "(update {:k 1} :k identity 1 2 3 4)"} {:suite "functions / arity enforcement" :label "through update" :expected :throws :actual "(update {:k 1} :k identity 1 2 3 4)"}
{:suite "functions / arity enforcement" :label "variadic below min" :expected :throws :actual "((fn [x & r] x))"} {:suite "functions / arity enforcement" :label "variadic below min" :expected :throws :actual "((fn [x & r] x))"}
{:suite "functions / arity enforcement" :label "variadic at min" :expected "nil" :actual "((fn [x & r] r) 1)"} {:suite "functions / arity enforcement" :label "variadic at min" :expected "nil" :actual "((fn [x & r] r) 1)"}
{:suite "functions / arity enforcement" :label "variadic above min" :expected "(quote (2 3))" :actual "((fn [x & r] r) 1 2 3)"} {:suite "functions / arity enforcement" :label "variadic above min" :expected "[2 3]" :actual "((fn [x & r] r) 1 2 3)"}
{:suite "functions / arity enforcement" :label "multi-arity no match" :expected :throws :actual "((fn ([x] x) ([x y] y)) 1 2 3)"} {:suite "functions / arity enforcement" :label "multi-arity no match" :expected :throws :actual "((fn ([x] x) ([x y] y)) 1 2 3)"}
{:suite "functions / arity enforcement" :label "multi-arity variadic below min" :expected :throws :actual "((fn ([x] x) ([x y & r] r)))"} {:suite "functions / arity enforcement" :label "multi-arity variadic below min" :expected :throws :actual "((fn ([x] x) ([x y & r] r)))"}
{:suite "functions / arity enforcement" :label "destructured param counts as one" :expected "3" :actual "((fn [[a b] c] c) [1 2] 3)"} {:suite "functions / arity enforcement" :label "destructured param counts as one" :expected "3" :actual "((fn [[a b] c] c) [1 2] 3)"}
@ -419,15 +419,15 @@
{:suite "clojure.core / futures — predicates" :label "future-done? after cancel" :expected "true" :actual "(let [f (future 1)] (future-cancel f) (future-done? f))"} {:suite "clojure.core / futures — predicates" :label "future-done? after cancel" :expected "true" :actual "(let [f (future 1)] (future-cancel f) (future-done? f))"}
{:suite "clojure.core / futures — predicates" :label "cancel an already-completed future returns false" :expected "false" :actual "(let [f (future 1)] (deref f) (future-cancel f))"} {:suite "clojure.core / futures — predicates" :label "cancel an already-completed future returns false" :expected "false" :actual "(let [f (future 1)] (deref f) (future-cancel f))"}
{:suite "clojure.core / futures — predicates" :label "future-cancelled? fresh is false" :expected "false" :actual "(future-cancelled? (future 1))"} {:suite "clojure.core / futures — predicates" :label "future-cancelled? fresh is false" :expected "false" :actual "(future-cancelled? (future 1))"}
{:suite "clojure.core / futures — snapshot (copy) semantics" :label "captured atom is snapshotted, not shared" :expected "0" :actual "(let [a (atom 0)] (deref (future (swap! a inc))) @a)"} {:suite "clojure.core / futures — snapshot (copy) semantics" :label "captured atom is snapshotted, not shared" :expected "1" :actual "(let [a (atom 0)] (deref (future (swap! a inc))) @a)"}
{:suite "clojure.core / futures — snapshot (copy) semantics" :label "future sees its own mutation" :expected "1" :actual "(let [a (atom 0)] (deref (future (swap! a inc))))"} {:suite "clojure.core / futures — snapshot (copy) semantics" :label "future sees its own mutation" :expected "1" :actual "(let [a (atom 0)] (deref (future (swap! a inc))))"}
{:suite "clojure.core / pmap family" :label "pmap values in order" :expected "[2 3 4]" :actual "(vec (pmap inc [1 2 3]))"} {:suite "clojure.core / pmap family" :label "pmap values in order" :expected "[2 3 4]" :actual "(vec (pmap inc [1 2 3]))"}
{:suite "clojure.core / pmap family" :label "pmap multi-coll" :expected "[5 7 9]" :actual "(vec (pmap + [1 2 3] [4 5 6]))"} {:suite "clojure.core / pmap family" :label "pmap multi-coll" :expected "[5 7 9]" :actual "(vec (pmap + [1 2 3] [4 5 6]))"}
{:suite "clojure.core / pmap family" :label "pmap empty" :expected "()" :actual "(pmap inc [])"} {:suite "clojure.core / pmap family" :label "pmap empty" :expected "[]" :actual "(pmap inc [])"}
{:suite "clojure.core / pmap family" :label "pmap is parallel" :expected "true" :actual "(do (deref (future :warmup)) (let [t0 (System/currentTimeMillis)] (dorun (pmap (fn [_] (Thread/sleep 200)) [1 2 3 4])) (< (- (System/currentTimeMillis) t0) 700)))"} {:suite "clojure.core / pmap family" :label "pmap is parallel" :expected "true" :actual "(do (deref (future :warmup)) (let [t0 (System/currentTimeMillis)] (dorun (pmap (fn [_] (Thread/sleep 200)) [1 2 3 4])) (< (- (System/currentTimeMillis) t0) 700)))"}
{:suite "clojure.core / pmap family" :label "pcalls" :expected "[1 2]" :actual "(vec (pcalls (fn [] 1) (fn [] 2)))"} {:suite "clojure.core / pmap family" :label "pcalls" :expected "[1 2]" :actual "(vec (pcalls (fn [] 1) (fn [] 2)))"}
{:suite "clojure.core / pmap family" :label "pvalues" :expected "[3 7]" :actual "(vec (pvalues (+ 1 2) (+ 3 4)))"} {:suite "clojure.core / pmap family" :label "pvalues" :expected "[3 7]" :actual "(vec (pvalues (+ 1 2) (+ 3 4)))"}
{:suite "clojure.core / pmap family" :label "snapshot semantics" :expected "0" :actual "(let [a (atom 0)] (dorun (pmap (fn [_] (swap! a inc)) [1 2])) (deref a))"} {:suite "clojure.core / pmap family" :label "snapshot semantics" :expected "2" :actual "(let [a (atom 0)] (dorun (pmap (fn [_] (swap! a inc)) [1 2])) (deref a))"}
{:suite "hierarchy / pure 3-arity" :label "derive returns new h" :expected "true" :actual "(let [h (derive (make-hierarchy) :rect :shape)] (and (map? h) (isa? h :rect :shape)))"} {:suite "hierarchy / pure 3-arity" :label "derive returns new h" :expected "true" :actual "(let [h (derive (make-hierarchy) :rect :shape)] (and (map? h) (isa? h :rect :shape)))"}
{:suite "hierarchy / pure 3-arity" :label "original unchanged" :expected "false" :actual "(let [h0 (make-hierarchy) h1 (derive h0 :rect :shape)] (isa? h0 :rect :shape))"} {:suite "hierarchy / pure 3-arity" :label "original unchanged" :expected "false" :actual "(let [h0 (make-hierarchy) h1 (derive h0 :rect :shape)] (isa? h0 :rect :shape))"}
{:suite "hierarchy / pure 3-arity" :label "isa? self" :expected "true" :actual "(isa? (make-hierarchy) :a :a)"} {:suite "hierarchy / pure 3-arity" :label "isa? self" :expected "true" :actual "(isa? (make-hierarchy) :a :a)"}
@ -557,7 +557,7 @@
{:suite "host-interop / ring-codec surface" :label "extend-protocol nil" :expected ":nil" :actual "(do (defprotocol Pn (pn [x])) (extend-protocol Pn nil (pn [n] :nil) Object (pn [o] :obj)) (pn nil))"} {:suite "host-interop / ring-codec surface" :label "extend-protocol nil" :expected ":nil" :actual "(do (defprotocol Pn (pn [x])) (extend-protocol Pn nil (pn [n] :nil) Object (pn [o] :obj)) (pn nil))"}
{:suite "host-interop / ring-codec surface" :label "extend-protocol Map covers sorted" :expected ":map" :actual "(do (defprotocol Ps (ps [x])) (extend-protocol Ps Map (ps [m] :map) Object (ps [o] :obj)) (ps (sorted-map 1 2)))"} {:suite "host-interop / ring-codec surface" :label "extend-protocol Map covers sorted" :expected ":map" :actual "(do (defprotocol Ps (ps [x])) (extend-protocol Ps Map (ps [m] :map) Object (ps [o] :obj)) (ps (sorted-map 1 2)))"}
{:suite "host-interop / ring-codec surface" :label "reduce over reified IReduceInit" :expected "42" :actual "(reduce + 0 (reify clojure.lang.IReduceInit (reduce [_ f init] (f (f init 40) 2))))"} {:suite "host-interop / ring-codec surface" :label "reduce over reified IReduceInit" :expected "42" :actual "(reduce + 0 (reify clojure.lang.IReduceInit (reduce [_ f init] (f (f init 40) 2))))"}
{:suite "host-interop / class tokens & readers" :label "class name evaluates to canonical string" :expected "\"java.lang.String\"" :actual "String"} {:suite "host-interop / class tokens & readers" :label "class name evaluates to canonical string" :expected "java.lang.String" :actual "String"}
{:suite "host-interop / class tokens & readers" :label "dispatch-only class name" :expected "\"java.io.InputStream\"" :actual "InputStream"} {:suite "host-interop / class tokens & readers" :label "dispatch-only class name" :expected "\"java.io.InputStream\"" :actual "InputStream"}
{:suite "host-interop / class tokens & readers" :label "(class x) matches the token" :expected "true" :actual "(= String (class \"abc\"))"} {:suite "host-interop / class tokens & readers" :label "(class x) matches the token" :expected "true" :actual "(= String (class \"abc\"))"}
{:suite "host-interop / class tokens & readers" :label "defmulti on class dispatches" :expected ":str" :actual "(do (defmulti cm (fn [x] (class x))) (defmethod cm String [x] :str) (cm \"a\"))"} {:suite "host-interop / class tokens & readers" :label "defmulti on class dispatches" :expected ":str" :actual "(do (defmulti cm (fn [x] (class x))) (defmethod cm String [x] :str) (cm \"a\"))"}
@ -574,7 +574,7 @@
{:suite "host-interop / bake env scrub" :label "listed name still reads" :expected "true" :actual "(do (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" \"HOME\") (let [r (System/getenv \"HOME\")] (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" nil) (string? r)))"} {:suite "host-interop / bake env scrub" :label "listed name still reads" :expected "true" :actual "(do (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" \"HOME\") (let [r (System/getenv \"HOME\")] (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" nil) (string? r)))"}
{:suite "host-interop / bake env scrub" :label "full snapshot filtered to the allowlist" :expected "true" :actual "(do (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" \"HOME\") (let [e (System/getenv)] (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" nil) (and (contains? (set (keys e)) \"HOME\") (= 1 (count (keys e))))))"} {:suite "host-interop / bake env scrub" :label "full snapshot filtered to the allowlist" :expected "true" :actual "(do (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" \"HOME\") (let [e (System/getenv)] (janet.os/setenv \"JOLT_BAKE_ENV_ALLOWLIST\" nil) (and (contains? (set (keys e)) \"HOME\") (= 1 (count (keys e))))))"}
{:suite "host-interop / bake env scrub" :label "no allowlist: unfiltered live reads" :expected "true" :actual "(string? (System/getenv \"HOME\"))"} {:suite "host-interop / bake env scrub" :label "no allowlist: unfiltered live reads" :expected "true" :actual "(string? (System/getenv \"HOME\"))"}
{:suite "host-interop / exception + HashMap shims" :label "getMessage on a thrown string" :expected "\"boom\"" :actual "(try (throw \"boom\") (catch Throwable e (.getMessage e)))"} {:suite "host-interop / exception + HashMap shims" :label "getMessage on a thrown string" :expected "\"class java.lang.String cannot be cast to class java.lang.Throwable (java.lang.String and java.lang.Throwable are in module java.base of loader 'bootstrap')\"" :actual "(try (throw \"boom\") (catch Throwable e (.getMessage e)))"}
{:suite "host-interop / exception + HashMap shims" :label "getMessage on ex-info" :expected "\"bad\"" :actual "(try (throw (ex-info \"bad\" {})) (catch Throwable e (.getMessage e)))"} {:suite "host-interop / exception + HashMap shims" :label "getMessage on ex-info" :expected "\"bad\"" :actual "(try (throw (ex-info \"bad\" {})) (catch Throwable e (.getMessage e)))"}
{:suite "host-interop / exception + HashMap shims" :label "HashMap get" :expected "2" :actual "(let [m (HashMap. {:a 1 :b 2})] (.get m :b))"} {:suite "host-interop / exception + HashMap shims" :label "HashMap get" :expected "2" :actual "(let [m (HashMap. {:a 1 :b 2})] (.get m :b))"}
{:suite "host-interop / exception + HashMap shims" :label "HashMap put + size" :expected "2" :actual "(let [m (HashMap. {})] (.put m :x 1) (.put m :y 2) (.size m))"} {:suite "host-interop / exception + HashMap shims" :label "HashMap put + size" :expected "2" :actual "(let [m (HashMap. {})] (.put m :x 1) (.put m :y 2) (.size m))"}
@ -648,7 +648,7 @@
{:suite "io / *in* + with-in-str + read-line" :label "read-line EOF nil" :expected "nil" :actual "(with-in-str \"\" (read-line))"} {:suite "io / *in* + with-in-str + read-line" :label "read-line EOF nil" :expected "nil" :actual "(with-in-str \"\" (read-line))"}
{:suite "io / *in* + with-in-str + read-line" :label "read-line after last" :expected "[\"x\" nil]" :actual "(with-in-str \"x\" [(read-line) (read-line)])"} {:suite "io / *in* + with-in-str + read-line" :label "read-line after last" :expected "[\"x\" nil]" :actual "(with-in-str \"x\" [(read-line) (read-line)])"}
{:suite "io / *in* + with-in-str + read-line" :label "empty line" :expected "[\"\" \"y\"]" :actual "(with-in-str \"\\ny\" [(read-line) (read-line)])"} {:suite "io / *in* + with-in-str + read-line" :label "empty line" :expected "[\"\" \"y\"]" :actual "(with-in-str \"\\ny\" [(read-line) (read-line)])"}
{:suite "io / *in* + with-in-str + read-line" :label "*in* is bound" :expected "true" :actual "(with-in-str \"\" (map? *in*))"} {:suite "io / *in* + with-in-str + read-line" :label "*in* is bound" :expected "false" :actual "(with-in-str \"\" (map? *in*))"}
{:suite "io / read" :label "read a form" :expected "42" :actual "(with-in-str \"42\" (read))"} {:suite "io / read" :label "read a form" :expected "42" :actual "(with-in-str \"42\" (read))"}
{:suite "io / read" :label "read a list form" :expected "(quote (+ 1 2))" :actual "(with-in-str \"(+ 1 2)\" (read))"} {:suite "io / read" :label "read a list form" :expected "(quote (+ 1 2))" :actual "(with-in-str \"(+ 1 2)\" (read))"}
{:suite "io / read" :label "read two forms" :expected "[1 2]" :actual "(with-in-str \"1 2\" [(read) (read)])"} {:suite "io / read" :label "read two forms" :expected "[1 2]" :actual "(with-in-str \"1 2\" [(read) (read)])"}
@ -673,9 +673,9 @@
{:suite "io / print family (overlay)" :label "prn keyword" :expected "\":k\\n\"" :actual "(with-out-str (prn :k))"} {:suite "io / print family (overlay)" :label "prn keyword" :expected "\":k\\n\"" :actual "(with-out-str (prn :k))"}
{:suite "io / print-method multimethod" :label "records print canonically" :expected "\"#user.Pt{:x 1, :y 2}\"" :actual "(do (defrecord Pt [x y]) (pr-str (->Pt 1 2)))"} {:suite "io / print-method multimethod" :label "records print canonically" :expected "\"#user.Pt{:x 1, :y 2}\"" :actual "(do (defrecord Pt [x y]) (pr-str (->Pt 1 2)))"}
{:suite "io / print-method multimethod" :label "records nested in colls" :expected "\"[#user.Pt{:x 1, :y 2}]\"" :actual "(do (defrecord Pt [x y]) (pr-str [(->Pt 1 2)]))"} {:suite "io / print-method multimethod" :label "records nested in colls" :expected "\"[#user.Pt{:x 1, :y 2}]\"" :actual "(do (defrecord Pt [x y]) (pr-str [(->Pt 1 2)]))"}
{:suite "io / print-method multimethod" :label "defmethod overrides a record, top level" :expected "\"<3,4>\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (pr-str (->Pt 3 4)))"} {:suite "io / print-method multimethod" :label "defmethod overrides a record, top level" :expected "\"#user.Pt{:x 3, :y 4}\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (pr-str (->Pt 3 4)))"}
{:suite "io / print-method multimethod" :label "defmethod fires nested in a map" :expected "\"{:p <5,6>}\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (pr-str {:p (->Pt 5 6)}))"} {:suite "io / print-method multimethod" :label "defmethod fires nested in a map" :expected "\"{:p #user.Pt{:x 5, :y 6}}\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (pr-str {:p (->Pt 5 6)}))"}
{:suite "io / print-method multimethod" :label "defmethod fires through prn" :expected "\"[<1,2>]\\n\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (with-out-str (prn [(->Pt 1 2)])))"} {:suite "io / print-method multimethod" :label "defmethod fires through prn" :expected "\"[#user.Pt{:x 1, :y 2}]\\n\"" :actual "(do (defrecord Pt [x y]) (defmethod print-method (quote user.Pt) [r w] (.write w (str \"<\" (:x r) \",\" (:y r) \">\"))) (with-out-str (prn [(->Pt 1 2)])))"}
{:suite "io / print-method multimethod" :label "direct call uses :default" :expected "\"42\"" :actual "(let [w (StringWriter.)] (print-method 42 w) (.toString w))"} {:suite "io / print-method multimethod" :label "direct call uses :default" :expected "\"42\"" :actual "(let [w (StringWriter.)] (print-method 42 w) (.toString w))"}
{:suite "io / print-method multimethod" :label "direct builtin override" :expected "\"#42#\"" :actual "(do (defmethod print-method :number [n w] (.write w (str \"#\" n \"#\"))) (let [w (StringWriter.)] (print-method 42 w) (.toString w)))"} {:suite "io / print-method multimethod" :label "direct builtin override" :expected "\"#42#\"" :actual "(do (defmethod print-method :number [n w] (.write w (str \"#\" n \"#\"))) (let [w (StringWriter.)] (print-method 42 w) (.toString w)))"}
{:suite "io / print-method multimethod" :label "print-dup routes to print-method" :expected "\"[1 2]\"" :actual "(let [w (StringWriter.)] (print-dup [1 2] w) (.toString w))"} {:suite "io / print-method multimethod" :label "print-dup routes to print-method" :expected "\"[1 2]\"" :actual "(let [w (StringWriter.)] (print-dup [1 2] w) (.toString w))"}
@ -684,19 +684,19 @@
{:suite "io / cold tagged types via print-method" :label "uuid" :expected "\"#uuid \\\"b6883c0a-0342-4007-9966-bc2dfa6b109e\\\"\"" :actual "(pr-str (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"} {:suite "io / cold tagged types via print-method" :label "uuid" :expected "\"#uuid \\\"b6883c0a-0342-4007-9966-bc2dfa6b109e\\\"\"" :actual "(pr-str (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"}
{:suite "io / cold tagged types via print-method" :label "uuid nested" :expected "\"[#uuid \\\"b6883c0a-0342-4007-9966-bc2dfa6b109e\\\"]\"" :actual "(pr-str [(parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\")])"} {:suite "io / cold tagged types via print-method" :label "uuid nested" :expected "\"[#uuid \\\"b6883c0a-0342-4007-9966-bc2dfa6b109e\\\"]\"" :actual "(pr-str [(parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\")])"}
{:suite "io / cold tagged types via print-method" :label "regex" :expected "\"#\\\"a+b\\\"\"" :actual "(pr-str #\"a+b\")"} {:suite "io / cold tagged types via print-method" :label "regex" :expected "\"#\\\"a+b\\\"\"" :actual "(pr-str #\"a+b\")"}
{:suite "io / cold tagged types via print-method" :label "transient vector" :expected "\"#<transient vector>\"" :actual "(pr-str (transient [1]))"} {:suite "io / cold tagged types via print-method" :label "transient vector" :expected "\"#object[clojure.lang.PersistentVector$TransientVector 0xa4ac20b \\\"clojure.lang.PersistentVector$TransientVector@a4ac20b\\\"]\"" :actual "(pr-str (transient [1]))"}
{:suite "io / cold tagged types via print-method" :label "transient map" :expected "\"#<transient map>\"" :actual "(pr-str (transient {:a 1}))"} {:suite "io / cold tagged types via print-method" :label "transient map" :expected "\"#object[clojure.lang.PersistentArrayMap$TransientArrayMap 0x79939c8 \\\"clojure.lang.PersistentArrayMap$TransientArrayMap@79939c8\\\"]\"" :actual "(pr-str (transient {:a 1}))"}
{:suite "io / cold tagged types via print-method" :label "atom override fires nested" :expected "\"{:a #atom[7]}\"" :actual "(do (defmethod print-method :jolt/atom [a w] (.write w (str \"#atom[\" (deref a) \"]\"))) (pr-str {:a (atom 7)}))"} {:suite "io / cold tagged types via print-method" :label "atom override fires nested" :expected "\"{:a #object[clojure.lang.Atom 0x2bb39d6c {:status :ready, :val 7}]}\"" :actual "(do (defmethod print-method :jolt/atom [a w] (.write w (str \"#atom[\" (deref a) \"]\"))) (pr-str {:a (atom 7)}))"}
{:suite "io / cold tagged types via print-method" :label "uuid through str unchanged" :expected "\"b6883c0a-0342-4007-9966-bc2dfa6b109e\"" :actual "(str (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"} {:suite "io / cold tagged types via print-method" :label "uuid through str unchanged" :expected "\"b6883c0a-0342-4007-9966-bc2dfa6b109e\"" :actual "(str (parse-uuid \"b6883c0a-0342-4007-9966-bc2dfa6b109e\"))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a cons'd call" :expected "3" :actual "(eval (cons (quote +) (quote (1 2))))"} {:suite "ISeq call forms (jolt-2rx)" :label "eval a cons'd call" :expected "3" :actual "(eval (cons (quote +) (quote (1 2))))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a list-built call" :expected "6" :actual "(eval (list (quote +) 1 2 3))"} {:suite "ISeq call forms (jolt-2rx)" :label "eval a list-built call" :expected "6" :actual "(eval (list (quote +) 1 2 3))"}
{:suite "ISeq call forms (jolt-2rx)" :label "eval a concat'd call" :expected "10" :actual "(eval (concat (list (quote +)) (list 1 2 3 4)))"} {:suite "ISeq call forms (jolt-2rx)" :label "eval a concat'd call" :expected "10" :actual "(eval (concat (list (quote +)) (list 1 2 3 4)))"}
{:suite "ISeq call forms (jolt-2rx)" :label "nested cons'd subform" :expected "7" :actual "(eval (list (quote +) 3 (cons (quote +) (quote (1 3)))))"} {:suite "ISeq call forms (jolt-2rx)" :label "nested cons'd subform" :expected "7" :actual "(eval (list (quote +) 3 (cons (quote +) (quote (1 3)))))"}
{:suite "ISeq call forms (jolt-2rx)" :label "empty list self-evals" :expected "()" :actual "(eval (list))"} {:suite "ISeq call forms (jolt-2rx)" :label "empty list self-evals" :expected "[]" :actual "(eval (list))"}
{:suite "ISeq call forms (jolt-2rx)" :label "macro output via cons" :expected "3" :actual "(do (defmacro mc [] (cons (quote +) (quote (1 2)))) (mc))"} {:suite "ISeq call forms (jolt-2rx)" :label "macro output via cons" :expected "3" :actual "(do (defmacro mc [] (cons (quote +) (quote (1 2)))) (mc))"}
{:suite "ISeq call forms (jolt-2rx)" :label "macro output via concat" :expected "6" :actual "(do (defmacro mk [] (concat (list (quote +)) (list 1 2 3))) (mk))"} {:suite "ISeq call forms (jolt-2rx)" :label "macro output via concat" :expected "6" :actual "(do (defmacro mk [] (concat (list (quote +)) (list 1 2 3))) (mk))"}
{:suite "ISeq call forms (jolt-2rx)" :label "vector value self-evals" :expected "[1 2 3]" :actual "(eval (vec [1 2 3]))"} {:suite "ISeq call forms (jolt-2rx)" :label "vector value self-evals" :expected "[1 2 3]" :actual "(eval (vec [1 2 3]))"}
{:suite "ISeq call forms (jolt-2rx)" :label "quoted list of data" :expected "(quote (1 2 3))" :actual "(quote (1 2 3))"} {:suite "ISeq call forms (jolt-2rx)" :label "quoted list of data" :expected "[1 2 3]" :actual "(quote (1 2 3))"}
{:suite "lazy / construction & laziness" :label "lazy-seq value" :expected "[1 2 3]" :actual "(take 3 (lazy-seq (cons 1 (lazy-seq (cons 2 (lazy-seq (cons 3 nil)))))))"} {:suite "lazy / construction & laziness" :label "lazy-seq value" :expected "[1 2 3]" :actual "(take 3 (lazy-seq (cons 1 (lazy-seq (cons 2 (lazy-seq (cons 3 nil)))))))"}
{:suite "lazy / construction & laziness" :label "not eagerly evaluated" :expected "0" :actual "(let [c (atom 0)] (lazy-seq (swap! c inc) nil) @c)"} {:suite "lazy / construction & laziness" :label "not eagerly evaluated" :expected "0" :actual "(let [c (atom 0)] (lazy-seq (swap! c inc) nil) @c)"}
{:suite "lazy / construction & laziness" :label "realized on demand" :expected "1" :actual "(let [c (atom 0) s (lazy-seq (swap! c inc) [1])] (first s) @c)"} {:suite "lazy / construction & laziness" :label "realized on demand" :expected "1" :actual "(let [c (atom 0) s (lazy-seq (swap! c inc) [1])] (first s) @c)"}
@ -752,7 +752,7 @@
{:suite "macros / defmacro" :label "simple macro" :expected "3" :actual "(do (defmacro m [a b] `(+ ~a ~b)) (m 1 2))"} {:suite "macros / defmacro" :label "simple macro" :expected "3" :actual "(do (defmacro m [a b] `(+ ~a ~b)) (m 1 2))"}
{:suite "macros / defmacro" :label "macro unless" :expected "1" :actual "(do (defmacro unless [c body] `(if ~c nil ~body)) (unless false 1))"} {:suite "macros / defmacro" :label "macro unless" :expected "1" :actual "(do (defmacro unless [c body] `(if ~c nil ~body)) (unless false 1))"}
{:suite "macros / defmacro" :label "macro with body splice" :expected "6" :actual "(do (defmacro msum [& xs] `(+ ~@xs)) (msum 1 2 3))"} {:suite "macros / defmacro" :label "macro with body splice" :expected "6" :actual "(do (defmacro msum [& xs] `(+ ~@xs)) (msum 1 2 3))"}
{:suite "macros / defmacro" :label "macroexpand-1" :expected "true" :actual "(do (defmacro m [x] `(inc ~x)) (list? (macroexpand-1 '(m 5))))"} {:suite "macros / defmacro" :label "macroexpand-1" :expected "false" :actual "(do (defmacro m [x] `(inc ~x)) (list? (macroexpand-1 '(m 5))))"}
{:suite "macros / defmacro" :label "gensym unique" :expected "false" :actual "(= (gensym) (gensym))"} {:suite "macros / defmacro" :label "gensym unique" :expected "false" :actual "(= (gensym) (gensym))"}
{:suite "macros / defmacro" :label "gensym# in template" :expected "true" :actual "(do (defmacro m [] `(let [x# 1] x#)) (= 1 (m)))"} {:suite "macros / defmacro" :label "gensym# in template" :expected "true" :actual "(do (defmacro m [] `(let [x# 1] x#)) (= 1 (m)))"}
{:suite "macros / defmacro" :label "#() inside syntax-quote" :expected "[2 4 6]" :actual "(do (defmacro m [] `(mapv #(* % 2) [1 2 3])) (m))"} {:suite "macros / defmacro" :label "#() inside syntax-quote" :expected "[2 4 6]" :actual "(do (defmacro m [] `(mapv #(* % 2) [1 2 3])) (m))"}
@ -845,7 +845,7 @@
{:suite "maps / literal construction" :label "values evaluate in source order" :expected "[1 2 3]" :actual "(do (def log (atom [])) {:a (swap! log conj 1) :b (swap! log conj 2) :c (swap! log conj 3)} (deref log))"} {:suite "maps / literal construction" :label "values evaluate in source order" :expected "[1 2 3]" :actual "(do (def log (atom [])) {:a (swap! log conj 1) :b (swap! log conj 2) :c (swap! log conj 3)} (deref log))"}
{:suite "maps / literal construction" :label "keys evaluate before their values, pairwise" :expected "[:k1 :v1 :k2 :v2]" :actual "(do (def log (atom [])) {(do (swap! log conj :k1) :a) (do (swap! log conj :v1) 1) (do (swap! log conj :k2) :b) (do (swap! log conj :v2) 2)} (deref log))"} {:suite "maps / literal construction" :label "keys evaluate before their values, pairwise" :expected "[:k1 :v1 :k2 :v2]" :actual "(do (def log (atom [])) {(do (swap! log conj :k1) :a) (do (swap! log conj :v1) 1) (do (swap! log conj :k2) :b) (do (swap! log conj :v2) 2)} (deref log))"}
{:suite "maps / literal construction" :label "source order with a nil value (phm form)" :expected "[1 2 3]" :actual "(do (def log (atom [])) {:a (do (swap! log conj 1) nil) :b (swap! log conj 2) :c (swap! log conj 3)} (deref log))"} {:suite "maps / literal construction" :label "source order with a nil value (phm form)" :expected "[1 2 3]" :actual "(do (def log (atom [])) {:a (do (swap! log conj 1) nil) :b (swap! log conj 2) :c (swap! log conj 3)} (deref log))"}
{:suite "maps / literal construction" :label "source order through syntax-quote" :expected "[1 2]" :actual "(do (def log (atom [])) (defmacro m-p3c [] `{:a ~(list 'swap! 'log 'conj 1) :b ~(list 'swap! 'log 'conj 2)}) (m-p3c) (deref log))"} {:suite "maps / literal construction" :label "source order through syntax-quote" :expected "[2 1]" :actual "(do (def log (atom [])) (defmacro m-p3c [] `{:a ~(list 'swap! 'log 'conj 1) :b ~(list 'swap! 'log 'conj 2)}) (m-p3c) (deref log))"}
{:suite "maps / literal construction" :label "count" :expected "3" :actual "(count {:a 1 :b 2 :c 3})"} {:suite "maps / literal construction" :label "count" :expected "3" :actual "(count {:a 1 :b 2 :c 3})"}
{:suite "maps / literal construction" :label "equality with phm" :expected "true" :actual "(= {:a 1 :b 2} (assoc {:a 1} :b 2))"} {:suite "maps / literal construction" :label "equality with phm" :expected "true" :actual "(= {:a 1 :b 2} (assoc {:a 1} :b 2))"}
{:suite "maps / literal construction" :label "keys work after assoc" :expected "2" :actual "(:b (assoc {:a 1 :b 2} :c 3))"} {:suite "maps / literal construction" :label "keys work after assoc" :expected "2" :actual "(:b (assoc {:a 1 :b 2} :c 3))"}
@ -854,8 +854,8 @@
{:suite "clojure.math (jolt-h79)" :label "pow" :expected "1024" :actual "(long (clojure.math/pow 2 10))"} {:suite "clojure.math (jolt-h79)" :label "pow" :expected "1024" :actual "(long (clojure.math/pow 2 10))"}
{:suite "clojure.math (jolt-h79)" :label "tan of 0" :expected "0" :actual "(long (clojure.math/tan 0))"} {:suite "clojure.math (jolt-h79)" :label "tan of 0" :expected "0" :actual "(long (clojure.math/tan 0))"}
{:suite "clojure.math (jolt-h79)" :label "round" :expected "3" :actual "(clojure.math/round 2.6)"} {:suite "clojure.math (jolt-h79)" :label "round" :expected "3" :actual "(clojure.math/round 2.6)"}
{:suite "clojure.math (jolt-h79)" :label "floor" :expected "2" :actual "(clojure.math/floor 2.9)"} {:suite "clojure.math (jolt-h79)" :label "floor" :expected "2.0" :actual "(clojure.math/floor 2.9)"}
{:suite "clojure.math (jolt-h79)" :label "signum" :expected "-1" :actual "(clojure.math/signum -7.2)"} {:suite "clojure.math (jolt-h79)" :label "signum" :expected "-1.0" :actual "(clojure.math/signum -7.2)"}
{:suite "clojure.math (jolt-h79)" :label "to-radians" :expected "true" :actual "(< 3.14 (clojure.math/to-radians 180) 3.15)"} {:suite "clojure.math (jolt-h79)" :label "to-radians" :expected "true" :actual "(< 3.14 (clojure.math/to-radians 180) 3.15)"}
{:suite "clojure.math (jolt-h79)" :label "PI" :expected "true" :actual "(< 3.14 clojure.math/PI 3.15)"} {:suite "clojure.math (jolt-h79)" :label "PI" :expected "true" :actual "(< 3.14 clojure.math/PI 3.15)"}
{:suite "clojure.math (jolt-h79)" :label "require + alias" :expected "5" :actual "(do (require '[clojure.math :as m]) (long (m/hypot 3 4)))"} {:suite "clojure.math (jolt-h79)" :label "require + alias" :expected "5" :actual "(do (require '[clojure.math :as m]) (long (m/hypot 3 4)))"}
@ -863,11 +863,11 @@
{:suite "calls / locals named like janet macros" :label "local fn named repeat" :expected "[1 1]" :actual "(let [repeat (fn [x] [x x])] (repeat 1))"} {:suite "calls / locals named like janet macros" :label "local fn named repeat" :expected "[1 1]" :actual "(let [repeat (fn [x] [x x])] (repeat 1))"}
{:suite "calls / locals named like janet macros" :label "local fn named seq" :expected ":end" :actual "((fn seq [n] (if (pos? n) (seq (dec n)) :end)) 2)"} {:suite "calls / locals named like janet macros" :label "local fn named seq" :expected ":end" :actual "((fn seq [n] (if (pos? n) (seq (dec n)) :end)) 2)"}
{:suite "calls / locals named like janet macros" :label "local fn named loop2" :expected "[2 1]" :actual "(let [with (fn [a b] [b a])] (with 1 2))"} {:suite "calls / locals named like janet macros" :label "local fn named loop2" :expected "[2 1]" :actual "(let [with (fn [a b] [b a])] (with 1 2))"}
{:suite "calls / locals named like janet macros" :label "overlay repeat self-call (regression)" :expected "(quote (0 0 0))" :actual "(take 3 (repeat 0))"} {:suite "calls / locals named like janet macros" :label "overlay repeat self-call (regression)" :expected "[0 0 0]" :actual "(take 3 (repeat 0))"}
{:suite "calls / locals named like janet macros" :label "closure param called" :expected "42" :actual "((fn [f] (f 41)) inc)"} {:suite "calls / locals named like janet macros" :label "closure param called" :expected "42" :actual "((fn [f] (f 41)) inc)"}
{:suite "calls / locals named like janet macros" :label "param holding a keyword (IFn leftover)" :expected "1" :actual "((fn [f] (f {:a 1})) :a)"} {:suite "calls / locals named like janet macros" :label "param holding a keyword (IFn leftover)" :expected "1" :actual "((fn [f] (f {:a 1})) :a)"}
{:suite "map / construct & predicate" :label "literal" :expected "{:a 1}" :actual "{:a 1}"} {:suite "map / construct & predicate" :label "literal" :expected "{:a 1}" :actual "{:a 1}"}
{:suite "map / construct & predicate" :label "hash-map" :expected "{:a 1, :b 2}" :actual "(hash-map :a 1 :b 2)"} {:suite "map / construct & predicate" :label "hash-map" :expected "{:b 2, :a 1}" :actual "(hash-map :a 1 :b 2)"}
{:suite "map / construct & predicate" :label "empty" :expected "{}" :actual "{}"} {:suite "map / construct & predicate" :label "empty" :expected "{}" :actual "{}"}
{:suite "map / construct & predicate" :label "map? true" :expected "true" :actual "(map? {:a 1})"} {:suite "map / construct & predicate" :label "map? true" :expected "true" :actual "(map? {:a 1})"}
{:suite "map / construct & predicate" :label "map? false on vector" :expected "false" :actual "(map? [1 2])"} {:suite "map / construct & predicate" :label "map? false on vector" :expected "false" :actual "(map? [1 2])"}
@ -1003,14 +1003,14 @@
{:suite "map / update-keys & update-vals (1.11)" :label "update-vals empty" :expected "{}" :actual "(update-vals {} inc)"} {:suite "map / update-keys & update-vals (1.11)" :label "update-vals empty" :expected "{}" :actual "(update-vals {} inc)"}
{:suite "map / update-keys & update-vals (1.11)" :label "update-vals nil" :expected "{}" :actual "(update-vals nil inc)"} {:suite "map / update-keys & update-vals (1.11)" :label "update-vals nil" :expected "{}" :actual "(update-vals nil inc)"}
{:suite "map / update-keys & update-vals (1.11)" :label "update-vals keeps keys" :expected "[:a :b]" :actual "(sort (keys (update-vals {:a 1 :b 2} inc)))"} {:suite "map / update-keys & update-vals (1.11)" :label "update-vals keeps keys" :expected "[:a :b]" :actual "(sort (keys (update-vals {:a 1 :b 2} inc)))"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "keys" :expected "(quote (:a))" :actual "(keys {:a 1})"} {:suite "maps / keys-vals-empty? as overlay fns" :label "keys" :expected "[:a]" :actual "(keys {:a 1})"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "keys empty map" :expected "nil" :actual "(keys {})"} {:suite "maps / keys-vals-empty? as overlay fns" :label "keys empty map" :expected "nil" :actual "(keys {})"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "keys nil" :expected "nil" :actual "(keys nil)"} {:suite "maps / keys-vals-empty? as overlay fns" :label "keys nil" :expected "nil" :actual "(keys nil)"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "vals" :expected "(quote (1))" :actual "(vals {:a 1})"} {:suite "maps / keys-vals-empty? as overlay fns" :label "vals" :expected "[1]" :actual "(vals {:a 1})"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "vals empty" :expected "nil" :actual "(vals {})"} {:suite "maps / keys-vals-empty? as overlay fns" :label "vals empty" :expected "nil" :actual "(vals {})"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "keys sorted order" :expected "[1 2 3]" :actual "(vec (keys (sorted-map 2 :b 1 :a 3 :c)))"} {:suite "maps / keys-vals-empty? as overlay fns" :label "keys sorted order" :expected "[1 2 3]" :actual "(vec (keys (sorted-map 2 :b 1 :a 3 :c)))"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "vals sorted order" :expected "[:a :b :c]" :actual "(vec (vals (sorted-map 2 :b 1 :a 3 :c)))"} {:suite "maps / keys-vals-empty? as overlay fns" :label "vals sorted order" :expected "[:a :b :c]" :actual "(vec (vals (sorted-map 2 :b 1 :a 3 :c)))"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "keys/vals zip" :expected "{:a 1 :b 2}" :actual "(zipmap (keys {:a 1 :b 2}) (vals {:a 1 :b 2}))"} {:suite "maps / keys-vals-empty? as overlay fns" :label "keys/vals zip" :expected "{:a 1, :b 2}" :actual "(zipmap (keys {:a 1 :b 2}) (vals {:a 1 :b 2}))"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "empty? map" :expected "true" :actual "(empty? {})"} {:suite "maps / keys-vals-empty? as overlay fns" :label "empty? map" :expected "true" :actual "(empty? {})"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "empty? vec" :expected "[true false]" :actual "[(empty? []) (empty? [1])]"} {:suite "maps / keys-vals-empty? as overlay fns" :label "empty? vec" :expected "[true false]" :actual "[(empty? []) (empty? [1])]"}
{:suite "maps / keys-vals-empty? as overlay fns" :label "empty? list" :expected "[true false]" :actual "[(empty? ()) (empty? (list 1))]"} {:suite "maps / keys-vals-empty? as overlay fns" :label "empty? list" :expected "[true false]" :actual "[(empty? ()) (empty? (list 1))]"}
@ -1053,7 +1053,7 @@
{:suite "metadata / with-meta & meta" :label "with-meta preserves value" :expected "true" :actual "(= [1 2 3] (with-meta [1 2 3] {:a 1}))"} {:suite "metadata / with-meta & meta" :label "with-meta preserves value" :expected "true" :actual "(= [1 2 3] (with-meta [1 2 3] {:a 1}))"}
{:suite "metadata / with-meta & meta" :label "with-meta on map" :expected "{:doc \"x\"}" :actual "(meta (with-meta {:k 1} {:doc \"x\"}))"} {:suite "metadata / with-meta & meta" :label "with-meta on map" :expected "{:doc \"x\"}" :actual "(meta (with-meta {:k 1} {:doc \"x\"}))"}
{:suite "metadata / with-meta & meta" :label "vary-meta" :expected "{:a 2}" :actual "(meta (vary-meta (with-meta [1] {:a 1}) update :a inc))"} {:suite "metadata / with-meta & meta" :label "vary-meta" :expected "{:a 2}" :actual "(meta (vary-meta (with-meta [1] {:a 1}) update :a inc))"}
{:suite "metadata / with-meta & meta" :label "vary-meta extra args" :expected "{:a 1 :b 2}" :actual "(meta (vary-meta (with-meta [1] {:a 1}) assoc :b 2))"} {:suite "metadata / with-meta & meta" :label "vary-meta extra args" :expected "{:a 1, :b 2}" :actual "(meta (vary-meta (with-meta [1] {:a 1}) assoc :b 2))"}
{:suite "metadata / with-meta & meta" :label "meta reader ^" :expected "{:tag :int}" :actual "(meta ^{:tag :int} [1 2])"} {:suite "metadata / with-meta & meta" :label "meta reader ^" :expected "{:tag :int}" :actual "(meta ^{:tag :int} [1 2])"}
{:suite "metadata / with-meta & meta" :label "with-meta on fn ok" :expected "true" :actual "(fn? (with-meta inc {:a 1}))"} {:suite "metadata / with-meta & meta" :label "with-meta on fn ok" :expected "true" :actual "(fn? (with-meta inc {:a 1}))"}
{:suite "metadata / with-meta & meta" :label "with-meta nil clears" :expected "nil" :actual "(meta (with-meta [1 2 3] nil))"} {:suite "metadata / with-meta & meta" :label "with-meta nil clears" :expected "nil" :actual "(meta (with-meta [1 2 3] nil))"}
@ -1066,7 +1066,7 @@
{:suite "metadata / type hints" :label "keyword hint -> true" :expected "true" :actual "(:foo (meta (read-string \"^:foo x\")))"} {:suite "metadata / type hints" :label "keyword hint -> true" :expected "true" :actual "(:foo (meta (read-string \"^:foo x\")))"}
{:suite "metadata / def metadata" :label "^:dynamic var binds" :expected "9" :actual "(do (def ^:dynamic *d* 1) (binding [*d* 9] *d*))"} {:suite "metadata / def metadata" :label "^:dynamic var binds" :expected "9" :actual "(do (def ^:dynamic *d* 1) (binding [*d* 9] *d*))"}
{:suite "metadata / def metadata" :label "^:private on var" :expected "true" :actual "(do (def ^:private pv 1) (:private (meta (var pv))))"} {:suite "metadata / def metadata" :label "^:private on var" :expected "true" :actual "(do (def ^:private pv 1) (:private (meta (var pv))))"}
{:suite "metadata / def metadata" :label "^Type tag on var" :expected "\"String\"" :actual "(do (def ^String tv \"a\") (:tag (meta (var tv))))"} {:suite "metadata / def metadata" :label "^Type tag on var" :expected "java.lang.String" :actual "(do (def ^String tv \"a\") (:tag (meta (var tv))))"}
{:suite "metadata / def metadata" :label "^{:doc} on var" :expected "\"hi\"" :actual "(do (def ^{:doc \"hi\"} dv 1) (:doc (meta (var dv))))"} {:suite "metadata / def metadata" :label "^{:doc} on var" :expected "\"hi\"" :actual "(do (def ^{:doc \"hi\"} dv 1) (:doc (meta (var dv))))"}
{:suite "metadata / def metadata" :label "(def name doc val) doc" :expected "\"d\"" :actual "(do (def dd \"d\" 5) (:doc (meta (var dd))))"} {:suite "metadata / def metadata" :label "(def name doc val) doc" :expected "\"d\"" :actual "(do (def dd \"d\" 5) (:doc (meta (var dd))))"}
{:suite "core / find-keyword + inst-ms*" :label "find-keyword" :expected ":a" :actual "(find-keyword \"a\")"} {:suite "core / find-keyword + inst-ms*" :label "find-keyword" :expected ":a" :actual "(find-keyword \"a\")"}
@ -1082,7 +1082,7 @@
{:suite "core / with-local-vars" :label "body result" :expected ":done" :actual "(with-local-vars [x 1] :done)"} {:suite "core / with-local-vars" :label "body result" :expected ":done" :actual "(with-local-vars [x 1] :done)"}
{:suite "core / with-open" :label "body result" :expected ":r" :actual "(let [log (atom [])] (with-open [c {:close (fn [] (swap! log conj :closed))}] :r))"} {:suite "core / with-open" :label "body result" :expected ":r" :actual "(let [log (atom [])] (with-open [c {:close (fn [] (swap! log conj :closed))}] :r))"}
{:suite "core / with-open" :label "close runs" :expected "[:closed]" :actual "(let [log (atom [])] (with-open [c {:close (fn [] (swap! log conj :closed))}] :r) (deref log))"} {:suite "core / with-open" :label "close runs" :expected "[:closed]" :actual "(let [log (atom [])] (with-open [c {:close (fn [] (swap! log conj :closed))}] :r) (deref log))"}
{:suite "core / with-open" :label "close on throw" :expected "[:closed]" :actual "(let [log (atom [])] (try (with-open [c {:close (fn [] (swap! log conj :closed))}] (throw (ex-info \"boom\" {}))) (catch Exception e nil)) (deref log))"} {:suite "core / with-open" :label "close on throw" :expected "[]" :actual "(let [log (atom [])] (try (with-open [c {:close (fn [] (swap! log conj :closed))}] (throw (ex-info \"boom\" {}))) (catch Exception e nil)) (deref log))"}
{:suite "core / with-open" :label "nested close order" :expected "[:inner :outer]" :actual "(let [log (atom [])] (with-open [a {:close (fn [] (swap! log conj :outer))} b {:close (fn [] (swap! log conj :inner))}] :r) (deref log))"} {:suite "core / with-open" :label "nested close order" :expected "[:inner :outer]" :actual "(let [log (atom [])] (with-open [a {:close (fn [] (swap! log conj :outer))} b {:close (fn [] (swap! log conj :inner))}] :r) (deref log))"}
{:suite "core / with-open" :label "zero bindings" :expected ":r" :actual "(with-open [] :r)"} {:suite "core / with-open" :label "zero bindings" :expected ":r" :actual "(with-open [] :r)"}
{:suite "core / with-open" :label "binding visible" :expected "5" :actual "(with-open [c {:close (fn [] nil) :v 5}] (:v c))"} {:suite "core / with-open" :label "binding visible" :expected "5" :actual "(with-open [c {:close (fn [] nil) :v 5}] (:v c))"}
@ -1096,9 +1096,9 @@
{:suite "core / read+string" :label "advances the stream" :expected "[1 2]" :actual "(with-in-str \"1 2\" [(first (read+string)) (first (read+string))])"} {:suite "core / read+string" :label "advances the stream" :expected "[1 2]" :actual "(with-in-str \"1 2\" [(first (read+string)) (first (read+string))])"}
{:suite "core / read+string" :label "EOF throws" :expected :throws :actual "(with-in-str \"\" (read+string))"} {:suite "core / read+string" :label "EOF throws" :expected :throws :actual "(with-in-str \"\" (read+string))"}
{:suite "core / read+string" :label "eof-value arity" :expected ":done" :actual "(first (with-in-str \"\" (read+string *in* false :done)))"} {:suite "core / read+string" :label "eof-value arity" :expected ":done" :actual "(first (with-in-str \"\" (read+string *in* false :done)))"}
{:suite "core / extenders" :label "lists extended type" :expected "[\"user.Rx\"]" :actual "(do (defprotocol Px (pm [x])) (defrecord Rx [] Px (pm [x] 1)) (mapv str (extenders Px)))"} {:suite "core / extenders" :label "lists extended type" :expected "[]" :actual "(do (defprotocol Px (pm [x])) (defrecord Rx [] Px (pm [x] 1)) (mapv str (extenders Px)))"}
{:suite "core / extenders" :label "nil when none" :expected "nil" :actual "(do (defprotocol Py (pn [x])) (extenders Py))"} {:suite "core / extenders" :label "nil when none" :expected "nil" :actual "(do (defprotocol Py (pn [x])) (extenders Py))"}
{:suite "core / extenders" :label "seq of tags" :expected "true" :actual "(do (defprotocol Pz (pz [x])) (defrecord Rz [] Pz (pz [x] 1)) (and (seq (extenders Pz)) (= 1 (count (extenders Pz)))))"} {:suite "core / extenders" :label "seq of tags" :expected "nil" :actual "(do (defprotocol Pz (pz [x])) (defrecord Rz [] Pz (pz [x] 1)) (and (seq (extenders Pz)) (= 1 (count (extenders Pz)))))"}
{:suite "multimethods / dispatch" :label "dispatch on value" :expected "\"two\"" :actual "(do (defmulti f identity) (defmethod f 1 [_] \"one\") (defmethod f 2 [_] \"two\") (f 2))"} {:suite "multimethods / dispatch" :label "dispatch on value" :expected "\"two\"" :actual "(do (defmulti f identity) (defmethod f 1 [_] \"one\") (defmethod f 2 [_] \"two\") (f 2))"}
{:suite "multimethods / dispatch" :label "dispatch on keyword fn" :expected "\"circle\"" :actual "(do (defmulti area :shape) (defmethod area :circle [_] \"circle\") (area {:shape :circle}))"} {:suite "multimethods / dispatch" :label "dispatch on keyword fn" :expected "\"circle\"" :actual "(do (defmulti area :shape) (defmethod area :circle [_] \"circle\") (area {:shape :circle}))"}
{:suite "multimethods / dispatch" :label ":default method" :expected "\"other\"" :actual "(do (defmulti f identity) (defmethod f 1 [_] \"one\") (defmethod f :default [_] \"other\") (f 99))"} {:suite "multimethods / dispatch" :label ":default method" :expected "\"other\"" :actual "(do (defmulti f identity) (defmethod f 1 [_] \"one\") (defmethod f :default [_] \"other\") (f 99))"}
@ -1152,7 +1152,7 @@
{:suite "namespaces / require & refer" :label "require :as" :expected "\"AB\"" :actual "(do (require '[clojure.string :as s]) (s/upper-case \"ab\"))"} {:suite "namespaces / require & refer" :label "require :as" :expected "\"AB\"" :actual "(do (require '[clojure.string :as s]) (s/upper-case \"ab\"))"}
{:suite "namespaces / require & refer" :label "require :refer" :expected "true" :actual "(do (require '[clojure.string :refer [blank?]]) (blank? \"\"))"} {:suite "namespaces / require & refer" :label "require :refer" :expected "true" :actual "(do (require '[clojure.string :refer [blank?]]) (blank? \"\"))"}
{:suite "namespaces / require & refer" :label "require :as + :refer" :expected "true" :actual "(do (require '[clojure.string :as s :refer [blank?]]) (and (blank? \"\") (= \"X\" (s/upper-case \"x\"))))"} {:suite "namespaces / require & refer" :label "require :as + :refer" :expected "true" :actual "(do (require '[clojure.string :as s :refer [blank?]]) (and (blank? \"\") (= \"X\" (s/upper-case \"x\"))))"}
{:suite "namespaces / require & refer" :label "require clojure.set" :expected "#{1 2 3}" :actual "(do (require '[clojure.set :as set]) (set/union #{1 2} #{3}))"} {:suite "namespaces / require & refer" :label "require clojure.set" :expected "#{1 3 2}" :actual "(do (require '[clojure.set :as set]) (set/union #{1 2} #{3}))"}
{:suite "namespaces / require & refer" :label "require clojure.walk" :expected "{:a 2}" :actual "(do (require '[clojure.walk :as w]) (w/postwalk (fn [x] (if (number? x) (inc x) x)) {:a 1}))"} {:suite "namespaces / require & refer" :label "require clojure.walk" :expected "{:a 2}" :actual "(do (require '[clojure.walk :as w]) (w/postwalk (fn [x] (if (number? x) (inc x) x)) {:a 1}))"}
{:suite "namespaces / require & refer" :label "walk keywordize-keys" :expected "{:a 1}" :actual "(do (require '[clojure.walk :as w]) (w/keywordize-keys {\"a\" 1}))"} {:suite "namespaces / require & refer" :label "walk keywordize-keys" :expected "{:a 1}" :actual "(do (require '[clojure.walk :as w]) (w/keywordize-keys {\"a\" 1}))"}
{:suite "namespaces / require & refer" :label "walk stringify-keys" :expected "true" :actual "(do (require '[clojure.walk :as w]) (= {\"a\" 1} (w/stringify-keys {:a 1})))"} {:suite "namespaces / require & refer" :label "walk stringify-keys" :expected "true" :actual "(do (require '[clojure.walk :as w]) (= {\"a\" 1} (w/stringify-keys {:a 1})))"}
@ -1187,7 +1187,7 @@
{:suite "numbers / arithmetic" :label "multiply" :expected "24" :actual "(* 2 3 4)"} {:suite "numbers / arithmetic" :label "multiply" :expected "24" :actual "(* 2 3 4)"}
{:suite "numbers / arithmetic" :label "multiply zero args" :expected "1" :actual "(*)"} {:suite "numbers / arithmetic" :label "multiply zero args" :expected "1" :actual "(*)"}
{:suite "numbers / arithmetic" :label "divide" :expected "2" :actual "(/ 10 5)"} {:suite "numbers / arithmetic" :label "divide" :expected "2" :actual "(/ 10 5)"}
{:suite "numbers / arithmetic" :label "divide to fraction" :expected "0.5" :actual "(/ 1 2)"} {:suite "numbers / arithmetic" :label "divide to fraction" :expected "1/2" :actual "(/ 1 2)"}
{:suite "numbers / arithmetic" :label "inc" :expected "6" :actual "(inc 5)"} {:suite "numbers / arithmetic" :label "inc" :expected "6" :actual "(inc 5)"}
{:suite "numbers / arithmetic" :label "dec" :expected "4" :actual "(dec 5)"} {:suite "numbers / arithmetic" :label "dec" :expected "4" :actual "(dec 5)"}
{:suite "numbers / arithmetic" :label "quot" :expected "3" :actual "(quot 10 3)"} {:suite "numbers / arithmetic" :label "quot" :expected "3" :actual "(quot 10 3)"}
@ -1239,13 +1239,13 @@
{:suite "numbers / floats & symbolic values" :label "NaN? number" :expected "false" :actual "(NaN? 1.0)"} {:suite "numbers / floats & symbolic values" :label "NaN? number" :expected "false" :actual "(NaN? 1.0)"}
{:suite "numbers / floats & symbolic values" :label "int? ##Inf false" :expected "false" :actual "(int? ##Inf)"} {:suite "numbers / floats & symbolic values" :label "int? ##Inf false" :expected "false" :actual "(int? ##Inf)"}
{:suite "numbers / floats & symbolic values" :label "pos-int? ##Inf" :expected "false" :actual "(pos-int? ##Inf)"} {:suite "numbers / floats & symbolic values" :label "pos-int? ##Inf" :expected "false" :actual "(pos-int? ##Inf)"}
{:suite "numbers / literal syntax" :label "bigint suffix N" :expected "42" :actual "42N"} {:suite "numbers / literal syntax" :label "bigint suffix N" :expected "42N" :actual "42N"}
{:suite "numbers / literal syntax" :label "bigint zero" :expected "0" :actual "0N"} {:suite "numbers / literal syntax" :label "bigint zero" :expected "0N" :actual "0N"}
{:suite "numbers / literal syntax" :label "bigdec suffix M" :expected "1.5" :actual "1.5M"} {:suite "numbers / literal syntax" :label "bigdec suffix M" :expected "1.5M" :actual "1.5M"}
{:suite "numbers / literal syntax" :label "bigdec int M" :expected "0" :actual "0.0M"} {:suite "numbers / literal syntax" :label "bigdec int M" :expected "0.0M" :actual "0.0M"}
{:suite "numbers / literal syntax" :label "ratio -> double" :expected "0.5" :actual "1/2"} {:suite "numbers / literal syntax" :label "ratio -> double" :expected "1/2" :actual "1/2"}
{:suite "numbers / literal syntax" :label "ratio 3/4" :expected "0.75" :actual "3/4"} {:suite "numbers / literal syntax" :label "ratio 3/4" :expected "3/4" :actual "3/4"}
{:suite "numbers / literal syntax" :label "neg ratio" :expected "-0.5" :actual "-1/2"} {:suite "numbers / literal syntax" :label "neg ratio" :expected "-1/2" :actual "-1/2"}
{:suite "numbers / literal syntax" :label "radix binary" :expected "10" :actual "2r1010"} {:suite "numbers / literal syntax" :label "radix binary" :expected "10" :actual "2r1010"}
{:suite "numbers / literal syntax" :label "radix hex-ish" :expected "255" :actual "16rFF"} {:suite "numbers / literal syntax" :label "radix hex-ish" :expected "255" :actual "16rFF"}
{:suite "numbers / literal syntax" :label "radix base36" :expected "35" :actual "36rZ"} {:suite "numbers / literal syntax" :label "radix base36" :expected "35" :actual "36rZ"}
@ -1270,8 +1270,8 @@
{:suite "numbers / printing of inf & nan" :label "str Infinity" :expected "\"Infinity\"" :actual "(str ##Inf)"} {:suite "numbers / printing of inf & nan" :label "str Infinity" :expected "\"Infinity\"" :actual "(str ##Inf)"}
{:suite "numbers / printing of inf & nan" :label "str -Infinity" :expected "\"-Infinity\"" :actual "(str ##-Inf)"} {:suite "numbers / printing of inf & nan" :label "str -Infinity" :expected "\"-Infinity\"" :actual "(str ##-Inf)"}
{:suite "numbers / printing of inf & nan" :label "str NaN" :expected "\"NaN\"" :actual "(str ##NaN)"} {:suite "numbers / printing of inf & nan" :label "str NaN" :expected "\"NaN\"" :actual "(str ##NaN)"}
{:suite "numbers / printing of inf & nan" :label "pr-str Infinity" :expected "\"Infinity\"" :actual "(pr-str ##Inf)"} {:suite "numbers / printing of inf & nan" :label "pr-str Infinity" :expected "\"##Inf\"" :actual "(pr-str ##Inf)"}
{:suite "numbers / printing of inf & nan" :label "inf inside coll" :expected "\"[Infinity]\"" :actual "(str [##Inf])"} {:suite "numbers / printing of inf & nan" :label "inf inside coll" :expected "\"[##Inf]\"" :actual "(str [##Inf])"}
{:suite "numbers / bit-ops & math" :label "bit-and" :expected "4" :actual "(bit-and 12 6)"} {:suite "numbers / bit-ops & math" :label "bit-and" :expected "4" :actual "(bit-and 12 6)"}
{:suite "numbers / bit-ops & math" :label "bit-or" :expected "14" :actual "(bit-or 12 6)"} {:suite "numbers / bit-ops & math" :label "bit-or" :expected "14" :actual "(bit-or 12 6)"}
{:suite "numbers / bit-ops & math" :label "bit-xor" :expected "10" :actual "(bit-xor 12 6)"} {:suite "numbers / bit-ops & math" :label "bit-xor" :expected "10" :actual "(bit-xor 12 6)"}
@ -1466,7 +1466,7 @@
{:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? yes" :expected "true" :actual "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"} {:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? yes" :expected "true" :actual "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"}
{:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? no" :expected "false" :actual "(tagged-literal? 1)"} {:suite "predicates / tagged-value (Phase 4)" :label "tagged-literal? no" :expected "false" :actual "(tagged-literal? 1)"}
{:suite "predicates / tagged-value (Phase 4)" :label "reader-conditional? no" :expected "false" :actual "(reader-conditional? 1)"} {:suite "predicates / tagged-value (Phase 4)" :label "reader-conditional? no" :expected "false" :actual "(reader-conditional? 1)"}
{:suite "predicates / tagged-value (Phase 4)" :label "chunked-seq? always false" :expected "false" :actual "(chunked-seq? (seq [1 2 3]))"} {:suite "predicates / tagged-value (Phase 4)" :label "chunked-seq? always false" :expected "true" :actual "(chunked-seq? (seq [1 2 3]))"}
{:suite "predicates / equality & identity" :label "= same" :expected "true" :actual "(= 1 1)"} {:suite "predicates / equality & identity" :label "= same" :expected "true" :actual "(= 1 1)"}
{:suite "predicates / equality & identity" :label "= vectors" :expected "true" :actual "(= [1 2] [1 2])"} {:suite "predicates / equality & identity" :label "= vectors" :expected "true" :actual "(= [1 2] [1 2])"}
{:suite "predicates / equality & identity" :label "= vector & list" :expected "true" :actual "(= [1 2] (list 1 2))"} {:suite "predicates / equality & identity" :label "= vector & list" :expected "true" :actual "(= [1 2] (list 1 2))"}
@ -1504,7 +1504,7 @@
{:suite "predicates / compare, type, any? (stage 3)" :label "compare cross-type throws" :expected :throws :actual "(compare 1 \"a\")"} {:suite "predicates / compare, type, any? (stage 3)" :label "compare cross-type throws" :expected :throws :actual "(compare 1 \"a\")"}
{:suite "predicates / compare, type, any? (stage 3)" :label "sort with compare" :expected "[nil 1 3]" :actual "(sort compare [3 nil 1])"} {:suite "predicates / compare, type, any? (stage 3)" :label "sort with compare" :expected "[nil 1 3]" :actual "(sort compare [3 nil 1])"}
{:suite "predicates / compare, type, any? (stage 3)" :label "type meta override" :expected ":custom" :actual "(type (with-meta [1] {:type :custom}))"} {:suite "predicates / compare, type, any? (stage 3)" :label "type meta override" :expected ":custom" :actual "(type (with-meta [1] {:type :custom}))"}
{:suite "predicates / compare, type, any? (stage 3)" :label "type of record" :expected "true" :actual "(do (defrecord TyR [a]) (= (symbol (str (type (->TyR 1)))) (type (->TyR 1))))"} {:suite "predicates / compare, type, any? (stage 3)" :label "type of record" :expected "false" :actual "(do (defrecord TyR [a]) (= (symbol (str (type (->TyR 1)))) (type (->TyR 1))))"}
{:suite "predicates / compare, type, any? (stage 3)" :label "any? value" :expected "true" :actual "(any? 5)"} {:suite "predicates / compare, type, any? (stage 3)" :label "any? value" :expected "true" :actual "(any? 5)"}
{:suite "predicates / compare, type, any? (stage 3)" :label "any? nil" :expected "true" :actual "(any? nil)"} {:suite "predicates / compare, type, any? (stage 3)" :label "any? nil" :expected "true" :actual "(any? nil)"}
{:suite "predicates / compare, type, any? (stage 3)" :label "gensym is symbol" :expected "true" :actual "(symbol? (gensym))"} {:suite "predicates / compare, type, any? (stage 3)" :label "gensym is symbol" :expected "true" :actual "(symbol? (gensym))"}
@ -1600,8 +1600,8 @@
{:suite "reader / syntax-quote" :label "splice empty" :expected "(quote (clojure.core/str))" :actual "(let [e []] `(str ~@e))"} {:suite "reader / syntax-quote" :label "splice empty" :expected "(quote (clojure.core/str))" :actual "(let [e []] `(str ~@e))"}
{:suite "reader / syntax-quote" :label "splice values" :expected "(quote (clojure.core/str 1 2 3))" :actual "(let [a [1 2 3]] `(str ~@a))"} {:suite "reader / syntax-quote" :label "splice values" :expected "(quote (clojure.core/str 1 2 3))" :actual "(let [a [1 2 3]] `(str ~@a))"}
{:suite "reader / syntax-quote" :label "splice in vector" :expected "[1 2 3 0 1 2 3]" :actual "(let [b [0] a [1 2 3] e []] `[~@e ~@a ~@b ~@a ~@e])"} {:suite "reader / syntax-quote" :label "splice in vector" :expected "[1 2 3 0 1 2 3]" :actual "(let [b [0] a [1 2 3] e []] `[~@e ~@a ~@b ~@a ~@e])"}
{:suite "reader / syntax-quote" :label "splice in set" :expected "#{0 1 2 3}" :actual "(let [b [0] a [1 2 3] e []] `#{~@e ~@a ~@b})"} {:suite "reader / syntax-quote" :label "splice in set" :expected "#{0 1 3 2}" :actual "(let [b [0] a [1 2 3] e []] `#{~@e ~@a ~@b})"}
{:suite "reader / syntax-quote" :label "unquote in set" :expected "#{5 9}" :actual "(let [x 5] `#{~x 9})"} {:suite "reader / syntax-quote" :label "unquote in set" :expected "#{9 5}" :actual "(let [x 5] `#{~x 9})"}
{:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard simple" :expected "2" :actual "(do #_1 2)"} {:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard simple" :expected "2" :actual "(do #_1 2)"}
{:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard in vector" :expected "[1 3]" :actual "[1 #_2 3]"} {:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard in vector" :expected "[1 3]" :actual "[1 #_2 3]"}
{:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard stacks" :expected "3" :actual "(do #_ #_ 1 2 3)"} {:suite "reader / discard, symbolic values, conditionals (spec 2.3)" :label "discard stacks" :expected "3" :actual "(do #_ #_ 1 2 3)"}
@ -1618,9 +1618,9 @@
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "string triple" :expected "true" :actual "(= \"meow\" ```\"meow\")"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "string triple" :expected "true" :actual "(= \"meow\" ```\"meow\")"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "number nested" :expected "true" :actual "(= 42 ``42)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "number nested" :expected "true" :actual "(= 42 ``42)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "keyword nested" :expected "true" :actual "(= :k ``:k)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "keyword nested" :expected "true" :actual "(= :k ``:k)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "nil nested" :expected "true" :actual "(nil? ``nil)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "nil nested" :expected "false" :actual "(nil? ``nil)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "char nested" :expected "true" :actual "(= \\a ``\\a)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "char nested" :expected "true" :actual "(= \\a ``\\a)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "bool nested" :expected "true" :actual "(= true ``true)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "bool nested" :expected "false" :actual "(= true ``true)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "symbol still qualifies" :expected "true" :actual "(= (quote clojure.core/map) `map)"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "symbol still qualifies" :expected "true" :actual "(= (quote clojure.core/map) `map)"}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "vector still templates" :expected "true" :actual "(= [1 2] `[1 ~(inc 1)])"} {:suite "reader / syntax-quote literal collapse (spec 2.4 S25)" :label "vector still templates" :expected "true" :actual "(= [1 2] `[1 ~(inc 1)])"}
{:suite "reader / scalar literals" :label "integer" :expected "42" :actual "42"} {:suite "reader / scalar literals" :label "integer" :expected "42" :actual "42"}
@ -1640,9 +1640,9 @@
{:suite "reader / scalar literals" :label "char unicode" :expected "65" :actual "(int \\u0041)"} {:suite "reader / scalar literals" :label "char unicode" :expected "65" :actual "(int \\u0041)"}
{:suite "reader / scalar literals" :label "hex literal" :expected "255" :actual "0xff"} {:suite "reader / scalar literals" :label "hex literal" :expected "255" :actual "0xff"}
{:suite "reader / scalar literals" :label "hex uppercase" :expected "31" :actual "0X1F"} {:suite "reader / scalar literals" :label "hex uppercase" :expected "31" :actual "0X1F"}
{:suite "reader / scalar literals" :label "bigint suffix N" :expected "42" :actual "42N"} {:suite "reader / scalar literals" :label "bigint suffix N" :expected "42N" :actual "42N"}
{:suite "reader / scalar literals" :label "bigdec suffix M" :expected "1.5" :actual "1.5M"} {:suite "reader / scalar literals" :label "bigdec suffix M" :expected "1.5M" :actual "1.5M"}
{:suite "reader / scalar literals" :label "ratio -> double" :expected "0.75" :actual "3/4"} {:suite "reader / scalar literals" :label "ratio -> double" :expected "3/4" :actual "3/4"}
{:suite "reader / scalar literals" :label "radix integer" :expected "255" :actual "16rFF"} {:suite "reader / scalar literals" :label "radix integer" :expected "255" :actual "16rFF"}
{:suite "reader / scalar literals" :label "exponent" :expected "1500.0" :actual "1.5e3"} {:suite "reader / scalar literals" :label "exponent" :expected "1500.0" :actual "1.5e3"}
{:suite "reader / scalar literals" :label "symbolic Infinity" :expected "true" :actual "(infinite? ##Inf)"} {:suite "reader / scalar literals" :label "symbolic Infinity" :expected "true" :actual "(infinite? ##Inf)"}
@ -1651,7 +1651,7 @@
{:suite "reader / collection literals" :label "vector" :expected "[1 2 3]" :actual "[1 2 3]"} {:suite "reader / collection literals" :label "vector" :expected "[1 2 3]" :actual "[1 2 3]"}
{:suite "reader / collection literals" :label "list quoted" :expected "[1 2 3]" :actual "'(1 2 3)"} {:suite "reader / collection literals" :label "list quoted" :expected "[1 2 3]" :actual "'(1 2 3)"}
{:suite "reader / collection literals" :label "map" :expected "{:a 1}" :actual "{:a 1}"} {:suite "reader / collection literals" :label "map" :expected "{:a 1}" :actual "{:a 1}"}
{:suite "reader / collection literals" :label "set" :expected "#{1 2 3}" :actual "#{1 2 3}"} {:suite "reader / collection literals" :label "set" :expected "#{1 3 2}" :actual "#{1 2 3}"}
{:suite "reader / collection literals" :label "nested" :expected "{:a [1 {:b 2}]}" :actual "{:a [1 {:b 2}]}"} {:suite "reader / collection literals" :label "nested" :expected "{:a [1 {:b 2}]}" :actual "{:a [1 {:b 2}]}"}
{:suite "reader / collection literals" :label "empty vector" :expected "[]" :actual "[]"} {:suite "reader / collection literals" :label "empty vector" :expected "[]" :actual "[]"}
{:suite "reader / collection literals" :label "empty map" :expected "{}" :actual "{}"} {:suite "reader / collection literals" :label "empty map" :expected "{}" :actual "{}"}
@ -1661,12 +1661,12 @@
{:suite "reader / dispatch & sugar" :label "anon fn %&" :expected "[2 3]" :actual "(#(vec %&) 2 3)"} {:suite "reader / dispatch & sugar" :label "anon fn %&" :expected "[2 3]" :actual "(#(vec %&) 2 3)"}
{:suite "reader / dispatch & sugar" :label "discard #_" :expected "[1 3]" :actual "[1 #_2 3]"} {:suite "reader / dispatch & sugar" :label "discard #_" :expected "[1 3]" :actual "[1 #_2 3]"}
{:suite "reader / dispatch & sugar" :label "regex literal" :expected "true" :actual "(= \"abc\" (re-find #\"abc\" \"xabcx\"))"} {:suite "reader / dispatch & sugar" :label "regex literal" :expected "true" :actual "(= \"abc\" (re-find #\"abc\" \"xabcx\"))"}
{:suite "reader / dispatch & sugar" :label "reader conditional" :expected "3" :actual "#?(:clj 1 :cljs 2 :default 3)"} {:suite "reader / dispatch & sugar" :label "reader conditional" :expected "1" :actual "#?(:clj 1 :cljs 2 :default 3)"}
{:suite "reader / dispatch & sugar" :label "reader cond :jolt" :expected "4" :actual "#?(:clj 1 :jolt 4 :default 3)"} {:suite "reader / dispatch & sugar" :label "reader cond :jolt" :expected "1" :actual "#?(:clj 1 :jolt 4 :default 3)"}
{:suite "reader / dispatch & sugar" :label "reader cond clause order" :expected "5" :actual "#?(:default 5 :jolt 6)"} {:suite "reader / dispatch & sugar" :label "reader cond clause order" :expected "5" :actual "#?(:default 5 :jolt 6)"}
{:suite "reader / dispatch & sugar" :label "reader cond no match" :expected "[]" :actual "[#?(:clj 1 :cljs 2)]"} {:suite "reader / dispatch & sugar" :label "reader cond no match" :expected "[1]" :actual "[#?(:clj 1 :cljs 2)]"}
{:suite "reader / dispatch & sugar" :label "reader cond splice" :expected "[1 2 3]" :actual "[#?@(:jolt [1 2 3] :cljs [4 5])]"} {:suite "reader / dispatch & sugar" :label "reader cond splice" :expected "[]" :actual "[#?@(:jolt [1 2 3] :cljs [4 5])]"}
{:suite "reader / dispatch & sugar" :label "reader cond splice no match" :expected "[]" :actual "[#?@(:clj [1 2 3] :cljs [4 5])]"} {:suite "reader / dispatch & sugar" :label "reader cond splice no match" :expected "[1 2 3]" :actual "[#?@(:clj [1 2 3] :cljs [4 5])]"}
{:suite "reader / dispatch & sugar" :label "inst literal reads" :expected "true" :actual "(some? #inst \"2020-01-01T00:00:00Z\")"} {:suite "reader / dispatch & sugar" :label "inst literal reads" :expected "true" :actual "(some? #inst \"2020-01-01T00:00:00Z\")"}
{:suite "reader / dispatch & sugar" :label "uuid literal" :expected "\"550e8400-e29b-41d4-a716-446655440000\"" :actual "(str #uuid \"550e8400-e29b-41d4-a716-446655440000\")"} {:suite "reader / dispatch & sugar" :label "uuid literal" :expected "\"550e8400-e29b-41d4-a716-446655440000\"" :actual "(str #uuid \"550e8400-e29b-41d4-a716-446655440000\")"}
{:suite "reader / dispatch & sugar" :label "tagged literal var" :expected "true" :actual "(var? #'+)"} {:suite "reader / dispatch & sugar" :label "tagged literal var" :expected "true" :actual "(var? #'+)"}
@ -1674,7 +1674,7 @@
{:suite "reader / dispatch & sugar" :label "meta sugar" :expected "{:t 1}" :actual "(meta ^{:t 1} [])"} {:suite "reader / dispatch & sugar" :label "meta sugar" :expected "{:t 1}" :actual "(meta ^{:t 1} [])"}
{:suite "reader / comments inside maps" :label "comment in value slot" :expected "{:a 1}" :actual "{:a ; note\n 1}"} {:suite "reader / comments inside maps" :label "comment in value slot" :expected "{:a 1}" :actual "{:a ; note\n 1}"}
{:suite "reader / comments inside maps" :label "comment before key" :expected "{:a 1}" :actual "{; lead\n :a 1}"} {:suite "reader / comments inside maps" :label "comment before key" :expected "{:a 1}" :actual "{; lead\n :a 1}"}
{:suite "reader / comments inside maps" :label "comment between entries" :expected "{:a 1 :b 2}" :actual "{:a 1 ; mid\n :b 2}"} {:suite "reader / comments inside maps" :label "comment between entries" :expected "{:a 1, :b 2}" :actual "{:a 1 ; mid\n :b 2}"}
{:suite "reader / comments inside maps" :label "discard in value slot" :expected "{:a 1}" :actual "{:a #_9 1}"} {:suite "reader / comments inside maps" :label "discard in value slot" :expected "{:a 1}" :actual "{:a #_9 1}"}
{:suite "reader / comments inside maps" :label "comment with parens" :expected "{:a {:b 1}}" :actual "{:a ; dev (REPL, etc)\n {:b 1}}"} {:suite "reader / comments inside maps" :label "comment with parens" :expected "{:a {:b 1}}" :actual "{:a ; dev (REPL, etc)\n {:b 1}}"}
{:suite "reader / comments inside maps" :label "nested with comments" :expected "{:x {:y 2}}" :actual "{:x ; outer\n {:y ; inner\n 2}}"} {:suite "reader / comments inside maps" :label "nested with comments" :expected "{:x {:y 2}}" :actual "{:x ; outer\n {:y ; inner\n 2}}"}
@ -1690,9 +1690,9 @@
{:suite "regex / re-matches" :label "partial = nil" :expected "nil" :actual "(re-matches #\"\\d+\" \"123abc\")"} {:suite "regex / re-matches" :label "partial = nil" :expected "nil" :actual "(re-matches #\"\\d+\" \"123abc\")"}
{:suite "regex / re-matches" :label "groups" :expected "[\"12\" \"1\" \"2\"]" :actual "(re-matches #\"(\\d)(\\d)\" \"12\")"} {:suite "regex / re-matches" :label "groups" :expected "[\"12\" \"1\" \"2\"]" :actual "(re-matches #\"(\\d)(\\d)\" \"12\")"}
{:suite "regex / re-matches" :label "no match nil" :expected "nil" :actual "(re-matches #\"x+\" \"yyy\")"} {:suite "regex / re-matches" :label "no match nil" :expected "nil" :actual "(re-matches #\"x+\" \"yyy\")"}
{:suite "regex / re-seq" :label "all matches" :expected "(quote (\"1\" \"22\" \"333\"))" :actual "(re-seq #\"\\d+\" \"a1b22c333\")"} {:suite "regex / re-seq" :label "all matches" :expected "[\"1\" \"22\" \"333\"]" :actual "(re-seq #\"\\d+\" \"a1b22c333\")"}
{:suite "regex / re-seq" :label "empty when none" :expected "nil" :actual "(seq (re-seq #\"z\" \"abc\"))"} {:suite "regex / re-seq" :label "empty when none" :expected "nil" :actual "(seq (re-seq #\"z\" \"abc\"))"}
{:suite "regex / re-seq" :label "words" :expected "(quote (\"foo\" \"bar\"))" :actual "(re-seq #\"\\w+\" \"foo bar\")"} {:suite "regex / re-seq" :label "words" :expected "[\"foo\" \"bar\"]" :actual "(re-seq #\"\\w+\" \"foo bar\")"}
{:suite "regex / re-pattern & string ops" :label "re-pattern build" :expected "\"hi\"" :actual "(re-find (re-pattern \"\\\\w+\") \"hi!\")"} {:suite "regex / re-pattern & string ops" :label "re-pattern build" :expected "\"hi\"" :actual "(re-find (re-pattern \"\\\\w+\") \"hi!\")"}
{:suite "regex / re-pattern & string ops" :label "re-pattern is regex?" :expected "true" :actual "(regex? (re-pattern \"a\"))"} {:suite "regex / re-pattern & string ops" :label "re-pattern is regex?" :expected "true" :actual "(regex? (re-pattern \"a\"))"}
{:suite "regex / re-pattern & string ops" :label "split on regex" :expected "[\"a\" \"b\" \"c\"]" :actual "(do (require '[clojure.string :as s]) (s/split \"a1b2c\" #\"\\d\"))"} {:suite "regex / re-pattern & string ops" :label "split on regex" :expected "[\"a\" \"b\" \"c\"]" :actual "(do (require '[clojure.string :as s]) (s/split \"a1b2c\" #\"\\d\"))"}
@ -1701,7 +1701,7 @@
{:suite "regex / \\p property classes" :label "p{L} ascii" :expected "\"hello\"" :actual "(re-matches #\"^\\p{L}+$\" \"hello\")"} {:suite "regex / \\p property classes" :label "p{L} ascii" :expected "\"hello\"" :actual "(re-matches #\"^\\p{L}+$\" \"hello\")"}
{:suite "regex / \\p property classes" :label "p{L} utf-8" :expected "true" :actual "(boolean (re-matches #\"^\\p{L}+$\" \"héllo\"))"} {:suite "regex / \\p property classes" :label "p{L} utf-8" :expected "true" :actual "(boolean (re-matches #\"^\\p{L}+$\" \"héllo\"))"}
{:suite "regex / \\p property classes" :label "p{L} rejects digits" :expected "false" :actual "(boolean (re-matches #\"^\\p{L}+$\" \"ab1\"))"} {:suite "regex / \\p property classes" :label "p{L} rejects digits" :expected "false" :actual "(boolean (re-matches #\"^\\p{L}+$\" \"ab1\"))"}
{:suite "regex / \\p property classes" :label "p{N}" :expected "(quote (\"12\" \"345\"))" :actual "(re-seq #\"\\p{N}+\" \"a12b345\")"} {:suite "regex / \\p property classes" :label "p{N}" :expected "[\"12\" \"345\"]" :actual "(re-seq #\"\\p{N}+\" \"a12b345\")"}
{:suite "regex / \\p property classes" :label "P{N} negation" :expected "\"abc\"" :actual "(re-matches #\"^\\P{N}+$\" \"abc\")"} {:suite "regex / \\p property classes" :label "P{N} negation" :expected "\"abc\"" :actual "(re-matches #\"^\\P{N}+$\" \"abc\")"}
{:suite "regex / \\p property classes" :label "inside class" :expected "\"a-1_b\"" :actual "(re-matches #\"^[\\p{N}\\p{L}_-]+$\" \"a-1_b\")"} {:suite "regex / \\p property classes" :label "inside class" :expected "\"a-1_b\"" :actual "(re-matches #\"^[\\p{N}\\p{L}_-]+$\" \"a-1_b\")"}
{:suite "regex / \\p property classes" :label "p{Lu}/p{Ll}" :expected "\"aB\"" :actual "(re-matches #\"^\\p{Ll}\\p{Lu}$\" \"aB\")"} {:suite "regex / \\p property classes" :label "p{Lu}/p{Ll}" :expected "\"aB\"" :actual "(re-matches #\"^\\p{Ll}\\p{Lu}$\" \"aB\")"}
@ -1771,7 +1771,7 @@
{:suite "seq / map filter reduce" :label "map 3 colls shortest" :expected "[12 15]" :actual "(map + [1 2] [4 5 6] [7 8 9])"} {:suite "seq / map filter reduce" :label "map 3 colls shortest" :expected "[12 15]" :actual "(map + [1 2] [4 5 6] [7 8 9])"}
{:suite "seq / map filter reduce" :label "map 4 colls" :expected "[16 20]" :actual "(map + [1 2] [3 4] [5 6] [7 8])"} {:suite "seq / map filter reduce" :label "map 4 colls" :expected "[16 20]" :actual "(map + [1 2] [3 4] [5 6] [7 8])"}
{:suite "seq / map filter reduce" :label "map 3 colls nils" :expected "[[1 :a 10] [nil :b 20] [3 nil 30]]" :actual "(map vector [1 nil 3] [:a :b nil] [10 20 30])"} {:suite "seq / map filter reduce" :label "map 3 colls nils" :expected "[[1 :a 10] [nil :b 20] [3 nil 30]]" :actual "(map vector [1 nil 3] [:a :b nil] [10 20 30])"}
{:suite "seq / map filter reduce" :label "map empty coll" :expected "()" :actual "(map + [] [1 2 3] [4 5 6])"} {:suite "seq / map filter reduce" :label "map empty coll" :expected "[]" :actual "(map + [] [1 2 3] [4 5 6])"}
{:suite "seq / map filter reduce" :label "map lazy+concrete" :expected "[11 22 33]" :actual "(map + (map identity [1 2 3]) [10 20 30])"} {:suite "seq / map filter reduce" :label "map lazy+concrete" :expected "[11 22 33]" :actual "(map + (map identity [1 2 3]) [10 20 30])"}
{:suite "seq / map filter reduce" :label "map-indexed" :expected "[[0 :a] [1 :b]]" :actual "(map-indexed vector [:a :b])"} {:suite "seq / map filter reduce" :label "map-indexed" :expected "[[0 :a] [1 :b]]" :actual "(map-indexed vector [:a :b])"}
{:suite "seq / map filter reduce" :label "mapv" :expected "[2 3 4]" :actual "(mapv inc [1 2 3])"} {:suite "seq / map filter reduce" :label "mapv" :expected "[2 3 4]" :actual "(mapv inc [1 2 3])"}
@ -1791,7 +1791,7 @@
{:suite "seq / map filter reduce" :label "mapcat" :expected "[1 1 2 2]" :actual "(mapcat (fn [x] [x x]) [1 2])"} {:suite "seq / map filter reduce" :label "mapcat" :expected "[1 1 2 2]" :actual "(mapcat (fn [x] [x x]) [1 2])"}
{:suite "seq / map filter reduce" :label "mapcat two colls" :expected "[1 3 2 4]" :actual "(mapcat vector [1 2] [3 4])"} {:suite "seq / map filter reduce" :label "mapcat two colls" :expected "[1 3 2 4]" :actual "(mapcat vector [1 2] [3 4])"}
{:suite "seq / map filter reduce" :label "mapcat three colls" :expected "[1 2 3]" :actual "(mapcat vector [1] [2] [3])"} {:suite "seq / map filter reduce" :label "mapcat three colls" :expected "[1 2 3]" :actual "(mapcat vector [1] [2] [3])"}
{:suite "seq / map filter reduce" :label "mapcat empty coll" :expected "()" :actual "(mapcat vector [] [1 2] [3 4])"} {:suite "seq / map filter reduce" :label "mapcat empty coll" :expected "[]" :actual "(mapcat vector [] [1 2] [3 4])"}
{:suite "seq / map filter reduce" :label "mapcat seqs" :expected "[1 2 3 4]" :actual "(mapcat identity [[1 2] [3 4]])"} {:suite "seq / map filter reduce" :label "mapcat seqs" :expected "[1 2 3 4]" :actual "(mapcat identity [[1 2] [3 4]])"}
{:suite "seq / map filter reduce" :label "keep" :expected "[1 3]" :actual "(keep (fn [x] (if (odd? x) x nil)) [1 2 3 4])"} {:suite "seq / map filter reduce" :label "keep" :expected "[1 3]" :actual "(keep (fn [x] (if (odd? x) x nil)) [1 2 3 4])"}
{:suite "seq / map filter reduce" :label "some truthy" :expected "true" :actual "(some even? [1 2 3])"} {:suite "seq / map filter reduce" :label "some truthy" :expected "true" :actual "(some even? [1 2 3])"}
@ -1907,8 +1907,8 @@
{:suite "seq / strictness round 3" :label "nthnext nil count" :expected :throws :actual "(nthnext [0 1 2] nil)"} {:suite "seq / strictness round 3" :label "nthnext nil count" :expected :throws :actual "(nthnext [0 1 2] nil)"}
{:suite "seq / strictness round 3" :label "update vec oob" :expected :throws :actual "(update [] 1 identity)"} {:suite "seq / strictness round 3" :label "update vec oob" :expected :throws :actual "(update [] 1 identity)"}
{:suite "seq / strictness round 3" :label "update vec kw key" :expected :throws :actual "(update [1 2 3] :k identity)"} {:suite "seq / strictness round 3" :label "update vec kw key" :expected :throws :actual "(update [1 2 3] :k identity)"}
{:suite "seq / overlay-migrated fns" :label "nthrest exhausted -> ()" :expected "()" :actual "(nthrest nil 100)"} {:suite "seq / overlay-migrated fns" :label "nthrest exhausted -> ()" :expected "[]" :actual "(nthrest nil 100)"}
{:suite "seq / overlay-migrated fns" :label "nthrest vec exhausted" :expected "()" :actual "(nthrest [1 2 3] 100)"} {:suite "seq / overlay-migrated fns" :label "nthrest vec exhausted" :expected "[]" :actual "(nthrest [1 2 3] 100)"}
{:suite "seq / overlay-migrated fns" :label "nthrest n<=0 keeps coll" :expected "[1 2 3]" :actual "(nthrest [1 2 3] 0)"} {:suite "seq / overlay-migrated fns" :label "nthrest n<=0 keeps coll" :expected "[1 2 3]" :actual "(nthrest [1 2 3] 0)"}
{:suite "seq / overlay-migrated fns" :label "nthrest drops n" :expected "[3 4 5]" :actual "(nthrest [1 2 3 4 5] 2)"} {:suite "seq / overlay-migrated fns" :label "nthrest drops n" :expected "[3 4 5]" :actual "(nthrest [1 2 3 4 5] 2)"}
{:suite "seq / overlay-migrated fns" :label "nthnext exhausted -> nil" :expected "nil" :actual "(nthnext [1 2] 5)"} {:suite "seq / overlay-migrated fns" :label "nthnext exhausted -> nil" :expected "nil" :actual "(nthnext [1 2] 5)"}
@ -1962,10 +1962,10 @@
{:suite "seq / partitionv & splitv-at (1.11)" :label "splitv-at past end" :expected "[[1 2] []]" :actual "(splitv-at 5 [1 2])"} {:suite "seq / partitionv & splitv-at (1.11)" :label "splitv-at past end" :expected "[[1 2] []]" :actual "(splitv-at 5 [1 2])"}
{:suite "sequences / linear walks over concrete collections" :label "rest of vector is a seq" :expected "true" :actual "(seq? (rest [1 2 3]))"} {:suite "sequences / linear walks over concrete collections" :label "rest of vector is a seq" :expected "true" :actual "(seq? (rest [1 2 3]))"}
{:suite "sequences / linear walks over concrete collections" :label "rest of vector not vector" :expected "false" :actual "(vector? (rest [1 2 3]))"} {:suite "sequences / linear walks over concrete collections" :label "rest of vector not vector" :expected "false" :actual "(vector? (rest [1 2 3]))"}
{:suite "sequences / linear walks over concrete collections" :label "rest values" :expected "(quote (2 3))" :actual "(rest [1 2 3])"} {:suite "sequences / linear walks over concrete collections" :label "rest values" :expected "[2 3]" :actual "(rest [1 2 3])"}
{:suite "sequences / linear walks over concrete collections" :label "next of vector" :expected "(quote (2 3))" :actual "(next [1 2 3])"} {:suite "sequences / linear walks over concrete collections" :label "next of vector" :expected "[2 3]" :actual "(next [1 2 3])"}
{:suite "sequences / linear walks over concrete collections" :label "next exhausts to nil" :expected "nil" :actual "(next [1])"} {:suite "sequences / linear walks over concrete collections" :label "next exhausts to nil" :expected "nil" :actual "(next [1])"}
{:suite "sequences / linear walks over concrete collections" :label "rest exhausts to ()" :expected "()" :actual "(rest [1])"} {:suite "sequences / linear walks over concrete collections" :label "rest exhausts to ()" :expected "[]" :actual "(rest [1])"}
{:suite "sequences / linear walks over concrete collections" :label "rest-loop scales (20k linear)" :expected "20000" :actual "(loop [xs (seq (vec (range 20000))) n 0] (if xs (recur (next xs) (inc n)) n))"} {:suite "sequences / linear walks over concrete collections" :label "rest-loop scales (20k linear)" :expected "20000" :actual "(loop [xs (seq (vec (range 20000))) n 0] (if xs (recur (next xs) (inc n)) n))"}
{:suite "sequences / linear walks over concrete collections" :label "mapv scales (50k linear)" :expected "50000" :actual "(count (mapv inc (vec (range 50000))))"} {:suite "sequences / linear walks over concrete collections" :label "mapv scales (50k linear)" :expected "50000" :actual "(count (mapv inc (vec (range 50000))))"}
{:suite "sequences / linear walks over concrete collections" :label "nested walk" :expected "[2 3]" :actual "(vec (rest (mapv inc [0 1 2])))"} {:suite "sequences / linear walks over concrete collections" :label "nested walk" :expected "[2 3]" :actual "(vec (rest (mapv inc [0 1 2])))"}
@ -1975,23 +1975,23 @@
{:suite "sequences / rest & next over set-like colls" :label "rest of empty set" :expected "0" :actual "(count (rest #{}))"} {:suite "sequences / rest & next over set-like colls" :label "rest of empty set" :expected "0" :actual "(count (rest #{}))"}
{:suite "sequences / rest & next over set-like colls" :label "next of map" :expected "true" :actual "(let [n (next {:a 1 :b 2})] (and (= 1 (count n)) (map-entry? (first n))))"} {:suite "sequences / rest & next over set-like colls" :label "next of map" :expected "true" :actual "(let [n (next {:a 1 :b 2})] (and (= 1 (count n)) (map-entry? (first n))))"}
{:suite "sequences / rest & next over set-like colls" :label "next of singleton map" :expected "nil" :actual "(next {:a 1})"} {:suite "sequences / rest & next over set-like colls" :label "next of singleton map" :expected "nil" :actual "(next {:a 1})"}
{:suite "sequences / rest & next over set-like colls" :label "rest of sorted-set" :expected "(quote (2 3))" :actual "(rest (sorted-set 3 1 2))"} {:suite "sequences / rest & next over set-like colls" :label "rest of sorted-set" :expected "[2 3]" :actual "(rest (sorted-set 3 1 2))"}
{:suite "sequences / rest & next over set-like colls" :label "next of sorted-map" :expected "(quote ([2 :b]))" :actual "(next (sorted-map 1 :a 2 :b))"} {:suite "sequences / rest & next over set-like colls" :label "next of sorted-map" :expected "[[2 :b]]" :actual "(next (sorted-map 1 :a 2 :b))"}
{:suite "sequences / rest & next over set-like colls" :label "every? over set" :expected "true" :actual "(every? pos? #{1 2 3})"} {:suite "sequences / rest & next over set-like colls" :label "every? over set" :expected "true" :actual "(every? pos? #{1 2 3})"}
{:suite "sequences / rest & next over set-like colls" :label "every? over set false" :expected "false" :actual "(every? odd? #{1 2})"} {:suite "sequences / rest & next over set-like colls" :label "every? over set false" :expected "false" :actual "(every? odd? #{1 2})"}
{:suite "sequences / rest & next over set-like colls" :label "every? over sorted-set" :expected "true" :actual "(every? pos? (sorted-set 1 2 3))"} {:suite "sequences / rest & next over set-like colls" :label "every? over sorted-set" :expected "true" :actual "(every? pos? (sorted-set 1 2 3))"}
{:suite "sequences / rest & next over set-like colls" :label "every? over map entries" :expected "true" :actual "(every? map-entry? (seq {:a 1 :b 2}))"} {:suite "sequences / rest & next over set-like colls" :label "every? over map entries" :expected "true" :actual "(every? map-entry? (seq {:a 1 :b 2}))"}
{:suite "set / construct & predicate" :label "literal" :expected "#{1 2 3}" :actual "#{1 2 3}"} {:suite "set / construct & predicate" :label "literal" :expected "#{1 3 2}" :actual "#{1 2 3}"}
{:suite "set / construct & predicate" :label "hash-set" :expected "#{1 2 3}" :actual "(hash-set 1 2 3)"} {:suite "set / construct & predicate" :label "hash-set" :expected "#{1 3 2}" :actual "(hash-set 1 2 3)"}
{:suite "set / construct & predicate" :label "set from vector" :expected "#{1 2 3}" :actual "(set [1 2 3 1])"} {:suite "set / construct & predicate" :label "set from vector" :expected "#{1 3 2}" :actual "(set [1 2 3 1])"}
{:suite "set / construct & predicate" :label "empty" :expected "#{}" :actual "#{}"} {:suite "set / construct & predicate" :label "empty" :expected "#{}" :actual "#{}"}
{:suite "set / construct & predicate" :label "set? true" :expected "true" :actual "(set? #{1})"} {:suite "set / construct & predicate" :label "set? true" :expected "true" :actual "(set? #{1})"}
{:suite "set / construct & predicate" :label "set? false on vector" :expected "false" :actual "(set? [1])"} {:suite "set / construct & predicate" :label "set? false on vector" :expected "false" :actual "(set? [1])"}
{:suite "set / construct & predicate" :label "count dedups" :expected "3" :actual "(count (set [1 1 2 3]))"} {:suite "set / construct & predicate" :label "count dedups" :expected "3" :actual "(count (set [1 1 2 3]))"}
{:suite "set / construct & predicate" :label "equality order-indep" :expected "true" :actual "(= #{1 2 3} #{3 2 1})"} {:suite "set / construct & predicate" :label "equality order-indep" :expected "true" :actual "(= #{1 2 3} #{3 2 1})"}
{:suite "set / construct & predicate" :label "into set" :expected "#{:a :b}" :actual "(into #{} [:a :b])"} {:suite "set / construct & predicate" :label "into set" :expected "#{:b :a}" :actual "(into #{} [:a :b])"}
{:suite "set / construct & predicate" :label "into non-empty set" :expected "#{1 2 3}" :actual "(into #{1} [2 3 2])"} {:suite "set / construct & predicate" :label "into non-empty set" :expected "#{1 3 2}" :actual "(into #{1} [2 3 2])"}
{:suite "set / operations" :label "conj adds" :expected "#{1 2 3}" :actual "(conj #{1 2} 3)"} {:suite "set / operations" :label "conj adds" :expected "#{1 3 2}" :actual "(conj #{1 2} 3)"}
{:suite "set / operations" :label "conj dup no-op" :expected "#{1 2}" :actual "(conj #{1 2} 1)"} {:suite "set / operations" :label "conj dup no-op" :expected "#{1 2}" :actual "(conj #{1 2} 1)"}
{:suite "set / operations" :label "disj removes" :expected "#{1 2}" :actual "(disj #{1 2 3} 3)"} {:suite "set / operations" :label "disj removes" :expected "#{1 2}" :actual "(disj #{1 2 3} 3)"}
{:suite "set / operations" :label "disj missing no-op" :expected "#{1 2}" :actual "(disj #{1 2} 9)"} {:suite "set / operations" :label "disj missing no-op" :expected "#{1 2}" :actual "(disj #{1 2} 9)"}
@ -2001,7 +2001,7 @@
{:suite "set / operations" :label "get missing nil" :expected "nil" :actual "(get #{1 2} 9)"} {:suite "set / operations" :label "get missing nil" :expected "nil" :actual "(get #{1 2} 9)"}
{:suite "set / operations" :label "set as fn present" :expected "2" :actual "(#{1 2 3} 2)"} {:suite "set / operations" :label "set as fn present" :expected "2" :actual "(#{1 2 3} 2)"}
{:suite "set / operations" :label "set as fn missing" :expected "nil" :actual "(#{1 2 3} 9)"} {:suite "set / operations" :label "set as fn missing" :expected "nil" :actual "(#{1 2 3} 9)"}
{:suite "set / literals & value elements" :label "literal evaluates elements" :expected "#{2 4}" :actual "#{(inc 1) (* 2 2)}"} {:suite "set / literals & value elements" :label "literal evaluates elements" :expected "#{4 2}" :actual "#{(inc 1) (* 2 2)}"}
{:suite "set / literals & value elements" :label "map elements by value" :expected "true" :actual "(= #{{:a 1}} #{(hash-map :a 1)})"} {:suite "set / literals & value elements" :label "map elements by value" :expected "true" :actual "(= #{{:a 1}} #{(hash-map :a 1)})"}
{:suite "set / literals & value elements" :label "contains? map by value" :expected "true" :actual "(contains? #{(hash-map :x 1)} {:x 1})"} {:suite "set / literals & value elements" :label "contains? map by value" :expected "true" :actual "(contains? #{(hash-map :x 1)} {:x 1})"}
{:suite "set / literals & value elements" :label "dedup equal maps" :expected "1" :actual "(count (set [{:a 1} (hash-map :a 1)]))"} {:suite "set / literals & value elements" :label "dedup equal maps" :expected "1" :actual "(count (set [{:a 1} (hash-map :a 1)]))"}
@ -2022,12 +2022,12 @@
{:suite "set / nil element (jolt-bn2p)" :label "transient disj! nil cnt" :expected "1" :actual "(count (persistent! (disj! (conj! (transient #{}) nil 1) nil)))"} {:suite "set / nil element (jolt-bn2p)" :label "transient disj! nil cnt" :expected "1" :actual "(count (persistent! (disj! (conj! (transient #{}) nil 1) nil)))"}
{:suite "set / nil element (jolt-bn2p)" :label "transient disj! removes" :expected "false" :actual "(contains? (persistent! (disj! (conj! (transient #{}) nil 1) nil)) nil)"} {:suite "set / nil element (jolt-bn2p)" :label "transient disj! removes" :expected "false" :actual "(contains? (persistent! (disj! (conj! (transient #{}) nil 1) nil)) nil)"}
{:suite "set / nil element (jolt-bn2p)" :label "transient of set w/ nil" :expected "true" :actual "(contains? (persistent! (transient (set [nil 1]))) nil)"} {:suite "set / nil element (jolt-bn2p)" :label "transient of set w/ nil" :expected "true" :actual "(contains? (persistent! (transient (set [nil 1]))) nil)"}
{:suite "clojure.set" :label "union" :expected "#{1 2 3 4}" :actual "(do (require (quote [clojure.set :as s])) (s/union #{1 2} #{3 4}))"} {:suite "clojure.set" :label "union" :expected "#{1 4 3 2}" :actual "(do (require (quote [clojure.set :as s])) (s/union #{1 2} #{3 4}))"}
{:suite "clojure.set" :label "intersection" :expected "#{2}" :actual "(do (require (quote [clojure.set :as s])) (s/intersection #{1 2} #{2 3}))"} {:suite "clojure.set" :label "intersection" :expected "#{2}" :actual "(do (require (quote [clojure.set :as s])) (s/intersection #{1 2} #{2 3}))"}
{:suite "clojure.set" :label "difference" :expected "#{1}" :actual "(do (require (quote [clojure.set :as s])) (s/difference #{1 2} #{2 3}))"} {:suite "clojure.set" :label "difference" :expected "#{1}" :actual "(do (require (quote [clojure.set :as s])) (s/difference #{1 2} #{2 3}))"}
{:suite "clojure.set" :label "subset? true" :expected "true" :actual "(do (require (quote [clojure.set :as s])) (s/subset? #{1} #{1 2}))"} {:suite "clojure.set" :label "subset? true" :expected "true" :actual "(do (require (quote [clojure.set :as s])) (s/subset? #{1} #{1 2}))"}
{:suite "clojure.set" :label "superset? true" :expected "true" :actual "(do (require (quote [clojure.set :as s])) (s/superset? #{1 2} #{1}))"} {:suite "clojure.set" :label "superset? true" :expected "true" :actual "(do (require (quote [clojure.set :as s])) (s/superset? #{1 2} #{1}))"}
{:suite "clojure.set" :label "select" :expected "#{2 4}" :actual "(do (require (quote [clojure.set :as s])) (s/select even? #{1 2 3 4}))"} {:suite "clojure.set" :label "select" :expected "#{4 2}" :actual "(do (require (quote [clojure.set :as s])) (s/select even? #{1 2 3 4}))"}
{:suite "clojure.set" :label "join" :expected "#{{:a 1, :b 2, :c 3}}" :actual "(do (require (quote [clojure.set :as s])) (s/join #{{:a 1 :b 2}} #{{:b 2 :c 3}}))"} {:suite "clojure.set" :label "join" :expected "#{{:a 1, :b 2, :c 3}}" :actual "(do (require (quote [clojure.set :as s])) (s/join #{{:a 1 :b 2}} #{{:b 2 :c 3}}))"}
{:suite "clojure.set" :label "map-invert" :expected "{1 :a}" :actual "(do (require (quote [clojure.set :as s])) (s/map-invert {:a 1}))"} {:suite "clojure.set" :label "map-invert" :expected "{1 :a}" :actual "(do (require (quote [clojure.set :as s])) (s/map-invert {:a 1}))"}
{:suite "clojure.set" :label "rename-keys" :expected "{:b 1}" :actual "(do (require (quote [clojure.set :as s])) (s/rename-keys {:a 1} {:a :b}))"} {:suite "clojure.set" :label "rename-keys" :expected "{:b 1}" :actual "(do (require (quote [clojure.set :as s])) (s/rename-keys {:a 1} {:a :b}))"}
@ -2197,8 +2197,8 @@
{:suite "state / promises" :label "promise undelivered" :expected "nil" :actual "(let [p (promise)] @p)"} {:suite "state / promises" :label "promise undelivered" :expected "nil" :actual "(let [p (promise)] @p)"}
{:suite "state / agents (synchronous shim)" :label "agent deref" :expected "0" :actual "(deref (agent 0))"} {:suite "state / agents (synchronous shim)" :label "agent deref" :expected "0" :actual "(deref (agent 0))"}
{:suite "state / agents (synchronous shim)" :label "agent with opts" :expected "0" :actual "(deref (agent 0 :error-mode :continue))"} {:suite "state / agents (synchronous shim)" :label "agent with opts" :expected "0" :actual "(deref (agent 0 :error-mode :continue))"}
{:suite "state / agents (synchronous shim)" :label "send-off applies" :expected "5" :actual "(let [a (agent 0)] (send-off a + 5) (deref a))"} {:suite "state / agents (synchronous shim)" :label "send-off applies" :expected "0" :actual "(let [a (agent 0)] (send-off a + 5) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "send applies" :expected "7" :actual "(let [a (agent 1)] (send a + 6) (deref a))"} {:suite "state / agents (synchronous shim)" :label "send applies" :expected "1" :actual "(let [a (agent 1)] (send a + 6) (deref a))"}
{:suite "state / agents (synchronous shim)" :label "agent-error nil" :expected "nil" :actual "(agent-error (agent 0))"} {:suite "state / agents (synchronous shim)" :label "agent-error nil" :expected "nil" :actual "(agent-error (agent 0))"}
{:suite "string / str & basics" :label "str concat" :expected "\"abc\"" :actual "(str \"a\" \"b\" \"c\")"} {:suite "string / str & basics" :label "str concat" :expected "\"abc\"" :actual "(str \"a\" \"b\" \"c\")"}
{:suite "string / str & basics" :label "str of numbers" :expected "\"12\"" :actual "(str 1 2)"} {:suite "string / str & basics" :label "str of numbers" :expected "\"12\"" :actual "(str 1 2)"}
@ -2274,7 +2274,7 @@
{:suite "transducers / into" :label "map-indexed xform" :expected "[[0 :a] [1 :b]]" :actual "(into [] (map-indexed vector) [:a :b])"} {:suite "transducers / into" :label "map-indexed xform" :expected "[[0 :a] [1 :b]]" :actual "(into [] (map-indexed vector) [:a :b])"}
{:suite "transducers / into" :label "mapcat xform" :expected "[1 1 2 2]" :actual "(into [] (mapcat (fn [x] [x x])) [1 2])"} {:suite "transducers / into" :label "mapcat xform" :expected "[1 1 2 2]" :actual "(into [] (mapcat (fn [x] [x x])) [1 2])"}
{:suite "transducers / into" :label "cat xform" :expected "[1 2 3 4]" :actual "(into [] cat [[1 2] [3 4]])"} {:suite "transducers / into" :label "cat xform" :expected "[1 2 3 4]" :actual "(into [] cat [[1 2] [3 4]])"}
{:suite "transducers / into" :label "into a set" :expected "#{2 3 4}" :actual "(into #{} (map inc) [1 2 3])"} {:suite "transducers / into" :label "into a set" :expected "#{4 3 2}" :actual "(into #{} (map inc) [1 2 3])"}
{:suite "transducers / compose" :label "comp map+filter" :expected "[2 4 6 8]" :actual "(into [] (comp (map (fn [x] (* x 2))) (filter even?)) [1 2 3 4])"} {:suite "transducers / compose" :label "comp map+filter" :expected "[2 4 6 8]" :actual "(into [] (comp (map (fn [x] (* x 2))) (filter even?)) [1 2 3 4])"}
{:suite "transducers / compose" :label "comp filter+map" :expected "[2 4]" :actual "(into [] (comp (filter odd?) (map inc)) [1 2 3 4])"} {:suite "transducers / compose" :label "comp filter+map" :expected "[2 4]" :actual "(into [] (comp (filter odd?) (map inc)) [1 2 3 4])"}
{:suite "transducers / compose" :label "comp three" :expected "[2]" :actual "(into [] (comp (map inc) (filter even?) (take 1)) [1 2 3 4])"} {:suite "transducers / compose" :label "comp three" :expected "[2]" :actual "(into [] (comp (map inc) (filter even?) (take 1)) [1 2 3 4])"}
@ -2301,7 +2301,7 @@
{:suite "reduce / honors reduced" :label "reduce empty calls f" :expected "0" :actual "(reduce + [])"} {:suite "reduce / honors reduced" :label "reduce empty calls f" :expected "0" :actual "(reduce + [])"}
{:suite "reduce / honors reduced" :label "reduce with-init" :expected "16" :actual "(reduce + 10 [1 2 3])"} {:suite "reduce / honors reduced" :label "reduce with-init" :expected "16" :actual "(reduce + 10 [1 2 3])"}
{:suite "reduce / honors reduced" :label "reduce reduced immediate" :expected ":x" :actual "(reduce (fn [a x] (reduced :x)) :init [1 2 3])"} {:suite "reduce / honors reduced" :label "reduce reduced immediate" :expected ":x" :actual "(reduce (fn [a x] (reduced :x)) :init [1 2 3])"}
{:suite "transducers / into & eduction (overlay)" :label "into list prepends" :expected "(quote (4 3 1 2))" :actual "(into (quote (1 2)) [3 4])"} {:suite "transducers / into & eduction (overlay)" :label "into list prepends" :expected "[4 3 1 2]" :actual "(into (quote (1 2)) [3 4])"}
{:suite "transducers / into & eduction (overlay)" :label "into sorted-map" :expected "{1 :a, 2 :b}" :actual "(into (sorted-map) [[2 :b] [1 :a]])"} {:suite "transducers / into & eduction (overlay)" :label "into sorted-map" :expected "{1 :a, 2 :b}" :actual "(into (sorted-map) [[2 :b] [1 :a]])"}
{:suite "transducers / into & eduction (overlay)" :label "into from map entry" :expected "[:a 1]" :actual "(into [] (first {:a 1}))"} {:suite "transducers / into & eduction (overlay)" :label "into from map entry" :expected "[:a 1]" :actual "(into [] (first {:a 1}))"}
{:suite "transducers / into & eduction (overlay)" :label "into xform on map" :expected "{:a 2}" :actual "(into {} (map (fn [e] [(key e) (inc (val e))])) {:a 1})"} {:suite "transducers / into & eduction (overlay)" :label "into xform on map" :expected "{:a 2}" :actual "(into {} (map (fn [e] [(key e) (inc (val e))])) {:a 1})"}
@ -2335,7 +2335,7 @@
{:suite "transient / map" :label "reduce build" :expected "{0 0, 1 1, 2 2}" :actual "(persistent! (reduce (fn [t i] (assoc! t i i)) (transient {}) (range 3)))"} {:suite "transient / map" :label "reduce build" :expected "{0 0, 1 1, 2 2}" :actual "(persistent! (reduce (fn [t i] (assoc! t i i)) (transient {}) (range 3)))"}
{:suite "transient / set" :label "conj! dedups" :expected "#{1 2 3}" :actual "(persistent! (conj! (transient #{}) 1 2 2 3))"} {:suite "transient / set" :label "conj! dedups" :expected "#{1 2 3}" :actual "(persistent! (conj! (transient #{}) 1 2 2 3))"}
{:suite "transient / set" :label "disj!" :expected "#{1 3}" :actual "(persistent! (disj! (transient #{1 2 3}) 2))"} {:suite "transient / set" :label "disj!" :expected "#{1 3}" :actual "(persistent! (disj! (transient #{1 2 3}) 2))"}
{:suite "transient / set" :label "from existing set" :expected "#{1 2 3}" :actual "(persistent! (conj! (transient #{1 2}) 3))"} {:suite "transient / set" :label "from existing set" :expected "#{1 3 2}" :actual "(persistent! (conj! (transient #{1 2}) 3))"}
{:suite "transient / set" :label "contains?" :expected "true" :actual "(contains? (transient #{1 2}) 1)"} {:suite "transient / set" :label "contains?" :expected "true" :actual "(contains? (transient #{1 2}) 1)"}
{:suite "transient / set" :label "count" :expected "2" :actual "(count (transient #{1 2}))"} {:suite "transient / set" :label "count" :expected "2" :actual "(count (transient #{1 2}))"}
{:suite "transient / set" :label "persistent! is a set" :expected "true" :actual "(set? (persistent! (transient #{1})))"} {:suite "transient / set" :label "persistent! is a set" :expected "true" :actual "(set? (persistent! (transient #{1})))"}
@ -2349,9 +2349,9 @@
{:suite "transient / invokable lookup" :label "set membership" :expected "2" :actual "((transient #{1 2 3}) 2)"} {:suite "transient / invokable lookup" :label "set membership" :expected "2" :actual "((transient #{1 2 3}) 2)"}
{:suite "transient / invokable lookup" :label "set miss default" :expected ":no" :actual "((transient #{1 2 3}) 42 :no)"} {:suite "transient / invokable lookup" :label "set miss default" :expected ":no" :actual "((transient #{1 2 3}) 42 :no)"}
{:suite "transient / invokable lookup" :label "collection key" :expected ":v" :actual "((transient {[1 2] :v}) [1 2])"} {:suite "transient / invokable lookup" :label "collection key" :expected ":v" :actual "((transient {[1 2] :v}) [1 2])"}
{:suite "transient / assoc! odd args throw" :label "map dangling key" :expected :throws :actual "(persistent! (assoc! (transient {}) :a 1 :b))"} {:suite "transient / assoc! odd args throw" :label "map dangling key" :expected "{:a 1, :b nil}" :actual "(persistent! (assoc! (transient {}) :a 1 :b))"}
{:suite "transient / assoc! odd args throw" :label "map lone key" :expected :throws :actual "(persistent! (assoc! (transient {}) :a))"} {:suite "transient / assoc! odd args throw" :label "map lone key" :expected :throws :actual "(persistent! (assoc! (transient {}) :a))"}
{:suite "transient / assoc! odd args throw" :label "vector dangling" :expected :throws :actual "(persistent! (apply assoc! (transient []) [0 9 1]))"} {:suite "transient / assoc! odd args throw" :label "vector dangling" :expected "[9 nil]" :actual "(persistent! (apply assoc! (transient []) [0 9 1]))"}
{:suite "transient / assoc! odd args throw" :label "even args still ok" :expected "true" :actual "(= {:a 1, :b 2} (persistent! (assoc! (transient {}) :a 1 :b 2)))"} {:suite "transient / assoc! odd args throw" :label "even args still ok" :expected "true" :actual "(= {:a 1, :b 2} (persistent! (assoc! (transient {}) :a 1 :b 2)))"}
{:suite "transient / invalidation" :label "conj! after persistent!" :expected :throws :actual "(let [t (transient [])] (persistent! t) (conj! t 1))"} {:suite "transient / invalidation" :label "conj! after persistent!" :expected :throws :actual "(let [t (transient [])] (persistent! t) (conj! t 1))"}
{:suite "transient / invalidation" :label "assoc! after persistent!" :expected :throws :actual "(let [t (transient {})] (persistent! t) (assoc! t :a 1))"} {:suite "transient / invalidation" :label "assoc! after persistent!" :expected :throws :actual "(let [t (transient {})] (persistent! t) (assoc! t :a 1))"}
@ -2424,7 +2424,7 @@
{:suite "untested / primed + division + bit ops" :label "inc'" :expected "2.5" :actual "(inc' 1.5)"} {:suite "untested / primed + division + bit ops" :label "inc'" :expected "2.5" :actual "(inc' 1.5)"}
{:suite "untested / primed + division + bit ops" :label "dec'" :expected "1.5" :actual "(dec' 2.5)"} {:suite "untested / primed + division + bit ops" :label "dec'" :expected "1.5" :actual "(dec' 2.5)"}
{:suite "untested / primed + division + bit ops" :label "/" :expected "2" :actual "(/ 6 3)"} {:suite "untested / primed + division + bit ops" :label "/" :expected "2" :actual "(/ 6 3)"}
{:suite "untested / primed + division + bit ops" :label "/ ratio-as-double" :expected "0.5" :actual "(/ 1 2)"} {:suite "untested / primed + division + bit ops" :label "/ ratio-as-double" :expected "1/2" :actual "(/ 1 2)"}
{:suite "untested / primed + division + bit ops" :label "bit-not" :expected "-6" :actual "(bit-not 5)"} {:suite "untested / primed + division + bit ops" :label "bit-not" :expected "-6" :actual "(bit-not 5)"}
{:suite "untested / primed + division + bit ops" :label "bit-and-not" :expected "4" :actual "(bit-and-not 12 10)"} {:suite "untested / primed + division + bit ops" :label "bit-and-not" :expected "4" :actual "(bit-and-not 12 10)"}
{:suite "untested / primed + division + bit ops" :label "bit-flip" :expected "3" :actual "(bit-flip 2 0)"} {:suite "untested / primed + division + bit ops" :label "bit-flip" :expected "3" :actual "(bit-flip 2 0)"}
@ -2438,7 +2438,7 @@
{:suite "untested / array stubs (vectors + host buffers)" :label "into-array" :expected "(quote (1 2))" :actual "(into-array [1 2])"} {:suite "untested / array stubs (vectors + host buffers)" :label "into-array" :expected "(quote (1 2))" :actual "(into-array [1 2])"}
{:suite "untested / array stubs (vectors + host buffers)" :label "to-array" :expected "(quote (1 2))" :actual "(to-array [1 2])"} {:suite "untested / array stubs (vectors + host buffers)" :label "to-array" :expected "(quote (1 2))" :actual "(to-array [1 2])"}
{:suite "untested / array stubs (vectors + host buffers)" :label "aclone vec" :expected "(quote (1 2))" :actual "(aclone [1 2])"} {:suite "untested / array stubs (vectors + host buffers)" :label "aclone vec" :expected "(quote (1 2))" :actual "(aclone [1 2])"}
{:suite "untested / array stubs (vectors + host buffers)" :label "aclone independent" :expected "(quote (9 2))" :actual "(let [a (aclone (to-array [1 2]))] (aset a 0 9) (seq a))"} {:suite "untested / array stubs (vectors + host buffers)" :label "aclone independent" :expected "[9 2]" :actual "(let [a (aclone (to-array [1 2]))] (aset a 0 9) (seq a))"}
{:suite "untested / array stubs (vectors + host buffers)" :label "aset/aget" :expected "9" :actual "(let [a (to-array [1 2 3])] (aset a 0 9) (aget a 0))"} {:suite "untested / array stubs (vectors + host buffers)" :label "aset/aget" :expected "9" :actual "(let [a (to-array [1 2 3])] (aset a 0 9) (aget a 0))"}
{:suite "untested / array stubs (vectors + host buffers)" :label "aset-int" :expected "7" :actual "(let [a (to-array [1 2])] (aset-int a 0 7) (aget a 0))"} {:suite "untested / array stubs (vectors + host buffers)" :label "aset-int" :expected "7" :actual "(let [a (to-array [1 2])] (aset-int a 0 7) (aget a 0))"}
{:suite "untested / array stubs (vectors + host buffers)" :label "aset-boolean" :expected "true" :actual "(let [a (to-array [1])] (aset-boolean a 0 true) (aget a 0))"} {:suite "untested / array stubs (vectors + host buffers)" :label "aset-boolean" :expected "true" :actual "(let [a (to-array [1])] (aset-boolean a 0 true) (aget a 0))"}
@ -2468,8 +2468,8 @@
{:suite "untested / typed coercion views" :label "byte" :expected "65" :actual "(byte 65)"} {:suite "untested / typed coercion views" :label "byte" :expected "65" :actual "(byte 65)"}
{:suite "untested / typed coercion views" :label "short" :expected "1" :actual "(short 1)"} {:suite "untested / typed coercion views" :label "short" :expected "1" :actual "(short 1)"}
{:suite "untested / typed coercion views" :label "long truncates" :expected "1" :actual "(long 1.7)"} {:suite "untested / typed coercion views" :label "long truncates" :expected "1" :actual "(long 1.7)"}
{:suite "untested / typed coercion views" :label "double" :expected "3" :actual "(double 3)"} {:suite "untested / typed coercion views" :label "double" :expected "3.0" :actual "(double 3)"}
{:suite "untested / typed coercion views" :label "float" :expected "3" :actual "(float 3)"} {:suite "untested / typed coercion views" :label "float" :expected "3.0" :actual "(float 3)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-add" :expected "3" :actual "(unchecked-add 1 2)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-add" :expected "3" :actual "(unchecked-add 1 2)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-add-int" :expected "3" :actual "(unchecked-add-int 1 2)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-add-int" :expected "3" :actual "(unchecked-add-int 1 2)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-subtract" :expected "3" :actual "(unchecked-subtract 5 2)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-subtract" :expected "3" :actual "(unchecked-subtract 5 2)"}
@ -2486,10 +2486,10 @@
{:suite "untested / unchecked-* are plain ops" :label "unchecked-remainder-int" :expected "1" :actual "(unchecked-remainder-int 7 2)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-remainder-int" :expected "1" :actual "(unchecked-remainder-int 7 2)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-int" :expected "3" :actual "(unchecked-int 3.7)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-int" :expected "3" :actual "(unchecked-int 3.7)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-long" :expected "3" :actual "(unchecked-long 3.7)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-long" :expected "3" :actual "(unchecked-long 3.7)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-double" :expected "3" :actual "(unchecked-double 3)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-double" :expected "3.0" :actual "(unchecked-double 3)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-float" :expected "3" :actual "(unchecked-float 3)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-float" :expected "3.0" :actual "(unchecked-float 3)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-byte" :expected "65" :actual "(unchecked-byte 65)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-byte" :expected "65" :actual "(unchecked-byte 65)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-char" :expected "97" :actual "(unchecked-char 97)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-char" :expected "\\a" :actual "(unchecked-char 97)"}
{:suite "untested / unchecked-* are plain ops" :label "unchecked-short" :expected "5" :actual "(unchecked-short 5)"} {:suite "untested / unchecked-* are plain ops" :label "unchecked-short" :expected "5" :actual "(unchecked-short 5)"}
{:suite "untested / chunk family (eager equivalents) + cat" :label "chunk round-trip" :expected "1" :actual "(let [cb (chunk-buffer 4)] (chunk-append cb 1) (chunk-first (chunk-cons (chunk cb) nil)))"} {:suite "untested / chunk family (eager equivalents) + cat" :label "chunk round-trip" :expected "1" :actual "(let [cb (chunk-buffer 4)] (chunk-append cb 1) (chunk-first (chunk-cons (chunk cb) nil)))"}
{:suite "untested / chunk family (eager equivalents) + cat" :label "cat transducer" :expected "[1 2 3]" :actual "(into [] cat [[1] [2 3]])"} {:suite "untested / chunk family (eager equivalents) + cat" :label "cat transducer" :expected "[1 2 3]" :actual "(into [] cat [[1] [2 3]])"}
@ -2497,10 +2497,10 @@
{:suite "untested / chunk family (eager equivalents) + cat" :label "ensure-reduced keeps reduced" :expected "true" :actual "(reduced? (ensure-reduced (reduced 5)))"} {:suite "untested / chunk family (eager equivalents) + cat" :label "ensure-reduced keeps reduced" :expected "true" :actual "(reduced? (ensure-reduced (reduced 5)))"}
{:suite "untested / chunk family (eager equivalents) + cat" :label "halt-when" :expected "4" :actual "(transduce (halt-when even?) conj [] [1 3 4 5])"} {:suite "untested / chunk family (eager equivalents) + cat" :label "halt-when" :expected "4" :actual "(transduce (halt-when even?) conj [] [1 3 4 5])"}
{:suite "untested / chunk family (eager equivalents) + cat" :label "chunk-next exhausted" :expected "nil" :actual "(let [cb (chunk-buffer 2)] (chunk-append cb 1) (chunk-next (chunk-cons (chunk cb) nil)))"} {:suite "untested / chunk family (eager equivalents) + cat" :label "chunk-next exhausted" :expected "nil" :actual "(let [cb (chunk-buffer 2)] (chunk-append cb 1) (chunk-next (chunk-cons (chunk cb) nil)))"}
{:suite "untested / chunk family (eager equivalents) + cat" :label "chunk-rest seqable" :expected "()" :actual "(let [cb (chunk-buffer 2)] (chunk-append cb 1) (vec (chunk-rest (chunk-cons (chunk cb) nil))))"} {:suite "untested / chunk family (eager equivalents) + cat" :label "chunk-rest seqable" :expected "[]" :actual "(let [cb (chunk-buffer 2)] (chunk-append cb 1) (vec (chunk-rest (chunk-cons (chunk cb) nil))))"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class number" :expected "\"java.lang.Number\"" :actual "(class 1)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class number" :expected "java.lang.Long" :actual "(class 1)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class string" :expected "\"java.lang.String\"" :actual "(class \"s\")"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class string" :expected "java.lang.String" :actual "(class \"s\")"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class keyword" :expected "\"clojure.lang.Keyword\"" :actual "(class :k)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class keyword" :expected "clojure.lang.Keyword" :actual "(class :k)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class nil" :expected "nil" :actual "(class nil)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "class nil" :expected "nil" :actual "(class nil)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "bean is the map" :expected "{:a 1}" :actual "(bean {:a 1})"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "bean is the map" :expected "{:a 1}" :actual "(bean {:a 1})"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "biginteger" :expected "\"5\"" :actual "(str (biginteger 5))"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "biginteger" :expected "\"5\"" :actual "(str (biginteger 5))"}
@ -2523,10 +2523,10 @@
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "print-method nil writer throws" :expected :throws :actual "(print-method 1 nil)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "print-method nil writer throws" :expected :throws :actual "(print-method 1 nil)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "uri? string" :expected "false" :actual "(uri? \"http://x\")"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "uri? string" :expected "false" :actual "(uri? \"http://x\")"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "uri? nil" :expected "false" :actual "(uri? nil)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "uri? nil" :expected "false" :actual "(uri? nil)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "definterface defines" :expected "true" :actual "(var? (definterface IFoo (foo [x])))"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "definterface defines" :expected "false" :actual "(var? (definterface IFoo (foo [x])))"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "enumeration-seq" :expected "(quote (1 2))" :actual "(enumeration-seq [1 2])"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "enumeration-seq" :expected "(quote (1 2))" :actual "(enumeration-seq [1 2])"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "iterator-seq" :expected "(quote (1 2))" :actual "(iterator-seq [1 2])"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "iterator-seq" :expected "(quote (1 2))" :actual "(iterator-seq [1 2])"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "seque passthrough" :expected "(quote (1 2))" :actual "(seque [1 2])"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "seque passthrough" :expected "[1 2]" :actual "(seque [1 2])"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "delay? true" :expected "true" :actual "(delay? (delay 1))"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "delay? true" :expected "true" :actual "(delay? (delay 1))"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "delay? false" :expected "false" :actual "(delay? 1)"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "delay? false" :expected "false" :actual "(delay? 1)"}
{:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "future-call" :expected "42" :actual "(deref (future-call (fn [] 42)))"} {:suite "untested / JVM-shape stubs (documented jolt behavior)" :label "future-call" :expected "42" :actual "(deref (future-call (fn [] 42)))"}
@ -2540,7 +2540,7 @@
{:suite "untested / ns + REPL machinery" :label "all-ns non-empty" :expected "true" :actual "(pos? (count (all-ns)))"} {:suite "untested / ns + REPL machinery" :label "all-ns non-empty" :expected "true" :actual "(pos? (count (all-ns)))"}
{:suite "untested / ns + REPL machinery" :label "ns-interns sees def" :expected "true" :actual "(do (def zz 1) (pos? (count (ns-interns (quote user)))))"} {:suite "untested / ns + REPL machinery" :label "ns-interns sees def" :expected "true" :actual "(do (def zz 1) (pos? (count (ns-interns (quote user)))))"}
{:suite "untested / ns + REPL machinery" :label "ns-interns countable" :expected "true" :actual "(map? (ns-interns (quote user)))"} {:suite "untested / ns + REPL machinery" :label "ns-interns countable" :expected "true" :actual "(map? (ns-interns (quote user)))"}
{:suite "untested / ns + REPL machinery" :label "ns-imports empty user" :expected "0" :actual "(count (ns-imports (quote user)))"} {:suite "untested / ns + REPL machinery" :label "ns-imports empty user" :expected "96" :actual "(count (ns-imports (quote user)))"}
{:suite "untested / ns + REPL machinery" :label "reset-meta!" :expected "{:doc \"d\"}" :actual "(do (def vv 1) (reset-meta! (var vv) {:doc \"d\"}))"} {:suite "untested / ns + REPL machinery" :label "reset-meta!" :expected "{:doc \"d\"}" :actual "(do (def vv 1) (reset-meta! (var vv) {:doc \"d\"}))"}
{:suite "untested / ns + REPL machinery" :label "prefers empty" :expected "{}" :actual "(do (defmulti mm identity) (prefers mm))"} {:suite "untested / ns + REPL machinery" :label "prefers empty" :expected "{}" :actual "(do (defmulti mm identity) (prefers mm))"}
{:suite "untested / ns + REPL machinery" :label "refer-clojure" :expected "nil" :actual "(refer-clojure)"} {:suite "untested / ns + REPL machinery" :label "refer-clojure" :expected "nil" :actual "(refer-clojure)"}
@ -2558,14 +2558,14 @@
{:suite "untested / ns + REPL machinery" :label "*3 nil" :expected "nil" :actual "*3"} {:suite "untested / ns + REPL machinery" :label "*3 nil" :expected "nil" :actual "*3"}
{:suite "untested / ns + REPL machinery" :label "*e nil" :expected "nil" :actual "*e"} {:suite "untested / ns + REPL machinery" :label "*e nil" :expected "nil" :actual "*e"}
{:suite "untested / ns + REPL machinery" :label "*unchecked-math*" :expected "false" :actual "*unchecked-math*"} {:suite "untested / ns + REPL machinery" :label "*unchecked-math*" :expected "false" :actual "*unchecked-math*"}
{:suite "untested / ns + REPL machinery" :label "*in* bound" :expected "true" :actual "(map? *in*)"} {:suite "untested / ns + REPL machinery" :label "*in* bound" :expected "false" :actual "(map? *in*)"}
{:suite "untested / misc seqs + binding machinery" :label "nfirst" :expected "(quote (2))" :actual "(nfirst [[1 2] [3]])"} {:suite "untested / misc seqs + binding machinery" :label "nfirst" :expected "[2]" :actual "(nfirst [[1 2] [3]])"}
{:suite "untested / misc seqs + binding machinery" :label "xml-seq root" :expected "1" :actual "(count (xml-seq {:tag :a :content []}))"} {:suite "untested / misc seqs + binding machinery" :label "xml-seq root" :expected "1" :actual "(count (xml-seq {:tag :a :content []}))"}
{:suite "untested / misc seqs + binding machinery" :label "xml-seq walks" :expected "2" :actual "(count (xml-seq {:tag :a :content [{:tag :b :content []}]}))"} {:suite "untested / misc seqs + binding machinery" :label "xml-seq walks" :expected "2" :actual "(count (xml-seq {:tag :a :content [{:tag :b :content []}]}))"}
{:suite "untested / misc seqs + binding machinery" :label "comp keyword stage" :expected "(quote (1 2))" :actual "((comp seq :content) {:content [1 2]})"} {:suite "untested / misc seqs + binding machinery" :label "comp keyword stage" :expected "[1 2]" :actual "((comp seq :content) {:content [1 2]})"}
{:suite "untested / misc seqs + binding machinery" :label "comp three stages" :expected "4" :actual "((comp inc inc :n) {:n 2})"} {:suite "untested / misc seqs + binding machinery" :label "comp three stages" :expected "4" :actual "((comp inc inc :n) {:n 2})"}
{:suite "untested / misc seqs + binding machinery" :label "random-sample all" :expected "(quote (1 2))" :actual "(random-sample 1.0 [1 2])"} {:suite "untested / misc seqs + binding machinery" :label "random-sample all" :expected "[1 2]" :actual "(random-sample 1.0 [1 2])"}
{:suite "untested / misc seqs + binding machinery" :label "random-sample none" :expected "()" :actual "(random-sample 0.0 [1 2])"} {:suite "untested / misc seqs + binding machinery" :label "random-sample none" :expected "[]" :actual "(random-sample 0.0 [1 2])"}
{:suite "untested / misc seqs + binding machinery" :label "reader-conditional builds" :expected "true" :actual "(reader-conditional? (reader-conditional (quote (:clj 1)) false))"} {:suite "untested / misc seqs + binding machinery" :label "reader-conditional builds" :expected "true" :actual "(reader-conditional? (reader-conditional (quote (:clj 1)) false))"}
{:suite "untested / misc seqs + binding machinery" :label "->Eduction" :expected "[2 3]" :actual "(vec (->Eduction (map inc) [1 2]))"} {:suite "untested / misc seqs + binding machinery" :label "->Eduction" :expected "[2 3]" :actual "(vec (->Eduction (map inc) [1 2]))"}
{:suite "untested / misc seqs + binding machinery" :label "bound-fn calls" :expected "42" :actual "((bound-fn [] 42))"} {:suite "untested / misc seqs + binding machinery" :label "bound-fn calls" :expected "42" :actual "((bound-fn [] 42))"}
@ -2652,21 +2652,21 @@
{:suite "vector / bulk build boundaries" :label "assoc into bulk vec" :expected "9" :actual "(nth (assoc (vec (range 1025)) 1000 9) 1000)"} {:suite "vector / bulk build boundaries" :label "assoc into bulk vec" :expected "9" :actual "(nth (assoc (vec (range 1025)) 1000 9) 1000)"}
{:suite "vector / bulk build boundaries" :label "into onto non-empty" :expected "[0 1 2 0 1]" :actual "(into (vec (range 3)) (range 2))"} {:suite "vector / bulk build boundaries" :label "into onto non-empty" :expected "[0 1 2 0 1]" :actual "(into (vec (range 3)) (range 2))"}
{:suite "clojure.walk / lists + seqs" :label "postwalk-replace symbol keys in a list" :expected "(quote (+ 2 2))" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {(quote x) 2} (quote (+ x x))))"} {:suite "clojure.walk / lists + seqs" :label "postwalk-replace symbol keys in a list" :expected "(quote (+ 2 2))" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {(quote x) 2} (quote (+ x x))))"}
{:suite "clojure.walk / lists + seqs" :label "postwalk descends a list" :expected "(quote (:a :a))" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk (fn [n] (if (symbol? n) :a n)) (quote (x y))))"} {:suite "clojure.walk / lists + seqs" :label "postwalk descends a list" :expected "[:a :a]" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk (fn [n] (if (symbol? n) :a n)) (quote (x y))))"}
{:suite "clojure.walk / lists + seqs" :label "prewalk-replace in a list" :expected "(quote (* 3 3))" :actual "(do (require (quote [clojure.walk :as w])) (w/prewalk-replace {(quote *) (quote *) (quote y) 3} (quote (* y y))))"} {:suite "clojure.walk / lists + seqs" :label "prewalk-replace in a list" :expected "(quote (* 3 3))" :actual "(do (require (quote [clojure.walk :as w])) (w/prewalk-replace {(quote *) (quote *) (quote y) 3} (quote (* y y))))"}
{:suite "clojure.walk / lists + seqs" :label "nested list + vector" :expected "(quote (1 [2 1]))" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {:a 1 :b 2} (quote (:a [:b :a]))))"} {:suite "clojure.walk / lists + seqs" :label "nested list + vector" :expected "[1 [2 1]]" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {:a 1 :b 2} (quote (:a [:b :a]))))"}
{:suite "clojure.walk / lists + seqs" :label "postwalk-replace in a vector" :expected "[:one 2 :one]" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {1 :one} [1 2 1]))"} {:suite "clojure.walk / lists + seqs" :label "postwalk-replace in a vector" :expected "[:one 2 :one]" :actual "(do (require (quote [clojure.walk :as w])) (w/postwalk-replace {1 :one} [1 2 1]))"}
{:suite "clojure.walk / lists + seqs" :label "keywordize-keys still works" :expected "{:a 1}" :actual "(do (require (quote [clojure.walk :as w])) (w/keywordize-keys {\"a\" 1}))"} {:suite "clojure.walk / lists + seqs" :label "keywordize-keys still works" :expected "{:a 1}" :actual "(do (require (quote [clojure.walk :as w])) (w/keywordize-keys {\"a\" 1}))"}
{:suite "clojure.walk / lists + seqs" :label "apply-template substitutes" :expected "(quote (+ 1 2))" :actual "(do (require (quote [clojure.template :as t])) (t/apply-template (quote [x y]) (quote (+ x y)) (quote (1 2))))"} {:suite "clojure.walk / lists + seqs" :label "apply-template substitutes" :expected "(quote (+ 1 2))" :actual "(do (require (quote [clojure.template :as t])) (t/apply-template (quote [x y]) (quote (+ x y)) (quote (1 2))))"}
{:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "(quote (0 1 1 2 3 5 8 13 21 34))" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"} {:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "[0 1 1 2 3 5 8 13 21 34]" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"}
{:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "(quote (11 22 33))" :actual "(map + [1 2 3] [10 20 30])"} {:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "[11 22 33]" :actual "(map + [1 2 3] [10 20 30])"}
{:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "(quote (12 24 36))" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"} {:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "[12 24 36]" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"}
{:suite "conformance / CRITICAL: multi-collection map" :label "map uneven (shortest)" :expected "(quote ([1 :a] [2 :b]))" :actual "(map vector [1 2 3] [:a :b])"} {:suite "conformance / CRITICAL: multi-collection map" :label "map uneven (shortest)" :expected "[[1 :a] [2 :b]]" :actual "(map vector [1 2 3] [:a :b])"}
{:suite "conformance / CRITICAL: multi-collection map" :label "map over range+vec" :expected "(quote (1 3 5))" :actual "(map + (range 3) [1 2 3])"} {:suite "conformance / CRITICAL: multi-collection map" :label "map over range+vec" :expected "[1 3 5]" :actual "(map + (range 3) [1 2 3])"}
{:suite "conformance / CRITICAL: multi-collection map" :label "map fn list arg" :expected "(quote (2 3 4))" :actual "(map inc (list 1 2 3))"} {:suite "conformance / CRITICAL: multi-collection map" :label "map fn list arg" :expected "[2 3 4]" :actual "(map inc (list 1 2 3))"}
{:suite "conformance / CRITICAL: iterate / infinite seqs" :label "iterate" :expected "(quote (0 1 2 3 4))" :actual "(take 5 (iterate inc 0))"} {:suite "conformance / CRITICAL: iterate / infinite seqs" :label "iterate" :expected "[0 1 2 3 4]" :actual "(take 5 (iterate inc 0))"}
{:suite "conformance / CRITICAL: iterate / infinite seqs" :label "iterate double" :expected "(quote (1 2 4 8 16))" :actual "(take 5 (iterate (fn [x] (* 2 x)) 1))"} {:suite "conformance / CRITICAL: iterate / infinite seqs" :label "iterate double" :expected "[1 2 4 8 16]" :actual "(take 5 (iterate (fn [x] (* 2 x)) 1))"}
{:suite "conformance / CRITICAL: iterate / infinite seqs" :label "range over inf map" :expected "(quote (1 2 3))" :actual "(take 3 (map inc (range)))"} {:suite "conformance / CRITICAL: iterate / infinite seqs" :label "range over inf map" :expected "[1 2 3]" :actual "(take 3 (map inc (range)))"}
{:suite "conformance / CRITICAL: iterate / infinite seqs" :label "count of take" :expected "100" :actual "(count (take 100 (range)))"} {:suite "conformance / CRITICAL: iterate / infinite seqs" :label "count of take" :expected "100" :actual "(count (take 100 (range)))"}
{:suite "conformance / CRITICAL: iterate / infinite seqs" :label "last of take" :expected "5" :actual "(last (take 5 (iterate inc 1)))"} {:suite "conformance / CRITICAL: iterate / infinite seqs" :label "last of take" :expected "5" :actual "(last (take 5 (iterate inc 1)))"}
{:suite "conformance / CRITICAL: collections as IFn" :label "map as fn miss" :expected "nil" :actual "({:a 1} :z)"} {:suite "conformance / CRITICAL: collections as IFn" :label "map as fn miss" :expected "nil" :actual "({:a 1} :z)"}
@ -2680,20 +2680,20 @@
{:suite "conformance / CRITICAL: collections as IFn" :label "disj one" :expected "#{1 3}" :actual "(disj #{1 2 3} 2)"} {:suite "conformance / CRITICAL: collections as IFn" :label "disj one" :expected "#{1 3}" :actual "(disj #{1 2 3} 2)"}
{:suite "conformance / CRITICAL: collections as IFn" :label "disj many" :expected "#{1}" :actual "(disj #{1 2 3} 2 3)"} {:suite "conformance / CRITICAL: collections as IFn" :label "disj many" :expected "#{1}" :actual "(disj #{1 2 3} 2 3)"}
{:suite "conformance / CRITICAL: collections as IFn" :label "disj absent" :expected "#{1 2}" :actual "(disj #{1 2} 5)"} {:suite "conformance / CRITICAL: collections as IFn" :label "disj absent" :expected "#{1 2}" :actual "(disj #{1 2} 5)"}
{:suite "conformance / CRITICAL: collections as IFn" :label "map fn over coll" :expected "(quote (1 3))" :actual "(map {:a 1 :b 3} [:a :b])"} {:suite "conformance / CRITICAL: collections as IFn" :label "map fn over coll" :expected "[1 3]" :actual "(map {:a 1 :b 3} [:a :b])"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "vec of map-result" :expected "[2 3 4]" :actual "(vec (map inc [1 2 3]))"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "vec of map-result" :expected "[2 3 4]" :actual "(vec (map inc [1 2 3]))"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "vec of range" :expected "[0 1 2 3 4]" :actual "(vec (range 5))"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "vec of range" :expected "[0 1 2 3 4]" :actual "(vec (range 5))"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into vec" :expected "[1 2 3 4 5 6]" :actual "(into [1 2 3] [4 5 6])"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into vec" :expected "[1 2 3 4 5 6]" :actual "(into [1 2 3] [4 5 6])"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into vec from lazy" :expected "[2 3 4]" :actual "(into [] (map inc [1 2 3]))"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into vec from lazy" :expected "[2 3 4]" :actual "(into [] (map inc [1 2 3]))"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into map pairs" :expected "{:a 1 :b 2}" :actual "(into {} [[:a 1] [:b 2]])"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into map pairs" :expected "{:a 1, :b 2}" :actual "(into {} [[:a 1] [:b 2]])"}
{:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into map onto map" :expected "{:a 1 :b 2 :c 3}" :actual "(into {:a 1} [[:b 2] [:c 3]])"} {:suite "conformance / CRITICAL: vec / into over lazy + maps" :label "into map onto map" :expected "{:a 1, :b 2, :c 3}" :actual "(into {:a 1} [[:b 2] [:c 3]])"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map vec is seq" :expected "true" :actual "(seq? (map inc [1 2 3]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map vec is seq" :expected "true" :actual "(seq? (map inc [1 2 3]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map vec not vector" :expected "false" :actual "(vector? (map inc [1 2 3]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map vec not vector" :expected "false" :actual "(vector? (map inc [1 2 3]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "filter vec is seq" :expected "true" :actual "(seq? (filter odd? [1 2 3]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "filter vec is seq" :expected "true" :actual "(seq? (filter odd? [1 2 3]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "take vec is seq" :expected "true" :actual "(seq? (take 2 [1 2 3]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "take vec is seq" :expected "true" :actual "(seq? (take 2 [1 2 3]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map over set" :expected "true" :actual "(= #{2 3 4} (set (map inc #{1 2 3})))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "map over set" :expected "true" :actual "(= #{2 3 4} (set (map inc #{1 2 3})))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "filter over map ev" :expected "(quote ([:b 2]))" :actual "(filter (fn [[k v]] (> v 1)) {:a 1 :b 2})"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "filter over map ev" :expected "[[:b 2]]" :actual "(filter (fn [[k v]] (> v 1)) {:a 1 :b 2})"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "cons cons lazy" :expected "(quote (1 2 3))" :actual "(cons 1 (cons 2 (lazy-seq (cons 3 nil))))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "cons cons lazy" :expected "[1 2 3]" :actual "(cons 1 (cons 2 (lazy-seq (cons 3 nil))))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "next empty lazy" :expected "nil" :actual "(next (take 1 [1]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "next empty lazy" :expected "nil" :actual "(next (take 1 [1]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "drop vec is seq" :expected "true" :actual "(seq? (drop 1 [1 2 3]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "drop vec is seq" :expected "true" :actual "(seq? (drop 1 [1 2 3]))"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "distinct vec is seq" :expected "true" :actual "(seq? (distinct [1 1 2]))"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "distinct vec is seq" :expected "true" :actual "(seq? (distinct [1 1 2]))"}
@ -2701,7 +2701,7 @@
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "nth lazy false elem" :expected "false" :actual "(nth (map identity [false 1 2]) 0)"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "nth lazy false elem" :expected "false" :actual "(nth (map identity [false 1 2]) 0)"}
{:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "nth lazy past false" :expected "2" :actual "(nth (drop 1 (list false 1 2)) 1)"} {:suite "conformance / Option A: lazy transformers return seqs, not vectors" :label "nth lazy past false" :expected "2" :actual "(nth (drop 1 (list false 1 2)) 1)"}
{:suite "conformance / HIGH: destructuring" :label "destr nested seq" :expected "[1 2 3]" :actual "(let [[a [b c]] [1 [2 3]]] [a b c])"} {:suite "conformance / HIGH: destructuring" :label "destr nested seq" :expected "[1 2 3]" :actual "(let [[a [b c]] [1 [2 3]]] [a b c])"}
{:suite "conformance / HIGH: destructuring" :label "destr rest+as" :expected "[1 (quote (2 3)) [1 2 3]]" :actual "(let [[a & r :as all] [1 2 3]] [a r all])"} {:suite "conformance / HIGH: destructuring" :label "destr rest+as" :expected "[1 [2 3] [1 2 3]]" :actual "(let [[a & r :as all] [1 2 3]] [a r all])"}
{:suite "conformance / HIGH: destructuring" :label "destr map :keys" :expected "[1 2]" :actual "(let [{:keys [a b]} {:a 1 :b 2}] [a b])"} {:suite "conformance / HIGH: destructuring" :label "destr map :keys" :expected "[1 2]" :actual "(let [{:keys [a b]} {:a 1 :b 2}] [a b])"}
{:suite "conformance / HIGH: destructuring" :label "destr map :or" :expected "[1 99]" :actual "(let [{:keys [a b] :or {b 99}} {:a 1}] [a b])"} {:suite "conformance / HIGH: destructuring" :label "destr map :or" :expected "[1 99]" :actual "(let [{:keys [a b] :or {b 99}} {:a 1}] [a b])"}
{:suite "conformance / HIGH: destructuring" :label "destr map :strs" :expected "[1 2]" :actual "(let [{:strs [a b]} {\"a\" 1 \"b\" 2}] [a b])"} {:suite "conformance / HIGH: destructuring" :label "destr map :strs" :expected "[1 2]" :actual "(let [{:strs [a b]} {\"a\" 1 \"b\" 2}] [a b])"}
@ -2712,7 +2712,7 @@
{:suite "conformance / HIGH: update / assoc-in on map literals" :label "get-in" :expected "1" :actual "(get-in {:a {:b {:c 1}}} [:a :b :c])"} {:suite "conformance / HIGH: update / assoc-in on map literals" :label "get-in" :expected "1" :actual "(get-in {:a {:b {:c 1}}} [:a :b :c])"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native mod floored" :expected "2" :actual "(mod -7 3)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native mod floored" :expected "2" :actual "(mod -7 3)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native rem truncated" :expected "-1" :actual "(rem -7 3)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native rem truncated" :expected "-1" :actual "(rem -7 3)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native unary div" :expected "0.5" :actual "(/ 2)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native unary div" :expected "1/2" :actual "(/ 2)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native chained div" :expected "1" :actual "(/ 6 3 2)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native chained div" :expected "1" :actual "(/ 6 3 2)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-and" :expected "8" :actual "(bit-and 12 10)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-and" :expected "8" :actual "(bit-and 12 10)"}
{:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-xor" :expected "6" :actual "(bit-xor 12 10)"} {:suite "conformance / native-op parity (compile emits janet ops at guarded arities)" :label "native bit-xor" :expected "6" :actual "(bit-xor 12 10)"}
@ -2771,45 +2771,45 @@
{:suite "conformance / HIGH: aliased namespace calls" :label "ns :use refers" :expected "42" :actual "(do (ns src.u) (def helper 42) (ns dst.u (:use [src.u])) helper)"} {:suite "conformance / HIGH: aliased namespace calls" :label "ns :use refers" :expected "42" :actual "(do (ns src.u) (def helper 42) (ns dst.u (:use [src.u])) helper)"}
{:suite "conformance / MED: missing core fns" :label "subvec" :expected "[2 3]" :actual "(subvec [1 2 3 4 5] 1 3)"} {:suite "conformance / MED: missing core fns" :label "subvec" :expected "[2 3]" :actual "(subvec [1 2 3 4 5] 1 3)"}
{:suite "conformance / MED: missing core fns" :label "subvec to-end" :expected "[3 4 5]" :actual "(subvec [1 2 3 4 5] 2)"} {:suite "conformance / MED: missing core fns" :label "subvec to-end" :expected "[3 4 5]" :actual "(subvec [1 2 3 4 5] 2)"}
{:suite "conformance / MED: missing core fns" :label "reduce-kv" :expected "{:a 2 :b 3}" :actual "(reduce-kv (fn [m k v] (assoc m k (inc v))) {} {:a 1 :b 2})"} {:suite "conformance / MED: missing core fns" :label "reduce-kv" :expected "{:a 2, :b 3}" :actual "(reduce-kv (fn [m k v] (assoc m k (inc v))) {} {:a 1 :b 2})"}
{:suite "conformance / iterating maps yields entries" :label "reduce over map" :expected "6" :actual "(reduce (fn [a [k v]] (+ a v)) 0 {:a 1 :b 2 :c 3})"} {:suite "conformance / iterating maps yields entries" :label "reduce over map" :expected "6" :actual "(reduce (fn [a [k v]] (+ a v)) 0 {:a 1 :b 2 :c 3})"}
{:suite "conformance / iterating maps yields entries" :label "into transform map" :expected "{:a 2 :b 3}" :actual "(into {} (map (fn [[k v]] [k (inc v)]) {:a 1 :b 2}))"} {:suite "conformance / iterating maps yields entries" :label "into transform map" :expected "{:a 2, :b 3}" :actual "(into {} (map (fn [[k v]] [k (inc v)]) {:a 1 :b 2}))"}
{:suite "conformance / iterating maps yields entries" :label "filter over map" :expected "true" :actual "(= [[:b 2]] (filterv (fn [[k v]] (> v 1)) {:a 1 :b 2}))"} {:suite "conformance / iterating maps yields entries" :label "filter over map" :expected "true" :actual "(= [[:b 2]] (filterv (fn [[k v]] (> v 1)) {:a 1 :b 2}))"}
{:suite "conformance / iterating maps yields entries" :label "tree-seq" :expected "(quote (1 2 3))" :actual "(map (fn [x] x) (filter (complement coll?) (tree-seq coll? seq [1 [2 [3]]])))"} {:suite "conformance / iterating maps yields entries" :label "tree-seq" :expected "[1 2 3]" :actual "(map (fn [x] x) (filter (complement coll?) (tree-seq coll? seq [1 [2 [3]]])))"}
{:suite "conformance / iterating maps yields entries" :label "key/val" :expected "true" :actual "(let [e (first {:k 9})] (and (= :k (key e)) (= 9 (val e))))"} {:suite "conformance / iterating maps yields entries" :label "key/val" :expected "true" :actual "(let [e (first {:k 9})] (and (= :k (key e)) (= 9 (val e))))"}
{:suite "conformance / iterating maps yields entries" :label "nat-int?" :expected "true" :actual "(and (nat-int? 0) (nat-int? 5) (not (nat-int? -1)))"} {:suite "conformance / iterating maps yields entries" :label "nat-int?" :expected "true" :actual "(and (nat-int? 0) (nat-int? 5) (not (nat-int? -1)))"}
{:suite "conformance / iterating maps yields entries" :label "list* prepend" :expected "(quote (1 2 3 4))" :actual "(list* 1 2 [3 4])"} {:suite "conformance / iterating maps yields entries" :label "list* prepend" :expected "[1 2 3 4]" :actual "(list* 1 2 [3 4])"}
{:suite "conformance / iterating maps yields entries" :label "cycle" :expected "(quote (1 2 3 1 2 3 1))" :actual "(take 7 (cycle [1 2 3]))"} {:suite "conformance / iterating maps yields entries" :label "cycle" :expected "[1 2 3 1 2 3 1]" :actual "(take 7 (cycle [1 2 3]))"}
{:suite "conformance / iterating maps yields entries" :label "partition-all" :expected "(quote ((1 2) (3 4) (5)))" :actual "(partition-all 2 [1 2 3 4 5])"} {:suite "conformance / iterating maps yields entries" :label "partition-all" :expected "[[1 2] [3 4] [5]]" :actual "(partition-all 2 [1 2 3 4 5])"}
{:suite "conformance / iterating maps yields entries" :label "reductions init" :expected "(quote (0 1 3 6))" :actual "(reductions + 0 [1 2 3])"} {:suite "conformance / iterating maps yields entries" :label "reductions init" :expected "[0 1 3 6]" :actual "(reductions + 0 [1 2 3])"}
{:suite "conformance / iterating maps yields entries" :label "dedupe" :expected "(quote (1 2 3 1))" :actual "(dedupe [1 1 2 3 3 1])"} {:suite "conformance / iterating maps yields entries" :label "dedupe" :expected "[1 2 3 1]" :actual "(dedupe [1 1 2 3 3 1])"}
{:suite "conformance / iterating maps yields entries" :label "partition-by odd?" :expected "(quote ((1 1) (2) (3 3)))" :actual "(partition-by odd? [1 1 2 3 3])"} {:suite "conformance / iterating maps yields entries" :label "partition-by odd?" :expected "[[1 1] [2] [3 3]]" :actual "(partition-by odd? [1 1 2 3 3])"}
{:suite "conformance / iterating maps yields entries" :label "reductions inf" :expected "(quote (0 1 3 6))" :actual "(take 4 (reductions + (range)))"} {:suite "conformance / iterating maps yields entries" :label "reductions inf" :expected "[0 1 3 6]" :actual "(take 4 (reductions + (range)))"}
{:suite "conformance / iterating maps yields entries" :label "tree-seq strict" :expected "10" :actual "(reduce + 0 (filter (complement coll?) (tree-seq coll? seq [1 [2 [3 4]]])))"} {:suite "conformance / iterating maps yields entries" :label "tree-seq strict" :expected "10" :actual "(reduce + 0 (filter (complement coll?) (tree-seq coll? seq [1 [2 [3 4]]])))"}
{:suite "conformance / iterating maps yields entries" :label "case nil + default" :expected "[:nilr :def]" :actual "(let [f (fn [x] (case x 1 :one nil :nilr :def))] [(f nil) (f 9)])"} {:suite "conformance / iterating maps yields entries" :label "case nil + default" :expected "[:nilr :def]" :actual "(let [f (fn [x] (case x 1 :one nil :nilr :def))] [(f nil) (f 9)])"}
{:suite "conformance / iterating maps yields entries" :label "case collection consts" :expected "[:v :m :s]" :actual "(let [f (fn [x] (case x [1 2] :v {:a 1} :m #{3} :s :def))] [(f [1 2]) (f {:a 1}) (f #{3})])"} {:suite "conformance / iterating maps yields entries" :label "case collection consts" :expected "[:v :m :s]" :actual "(let [f (fn [x] (case x [1 2] :v {:a 1} :m #{3} :s :def))] [(f [1 2]) (f {:a 1}) (f #{3})])"}
{:suite "conformance / iterating maps yields entries" :label "seq of nil-first" :expected "true" :actual "(boolean (seq (cons nil (list 1))))"} {:suite "conformance / iterating maps yields entries" :label "seq of nil-first" :expected "true" :actual "(boolean (seq (cons nil (list 1))))"}
{:suite "conformance / iterating maps yields entries" :label "reverse nil elem" :expected "[2 nil 1]" :actual "(vec (reverse (list 1 nil 2)))"} {:suite "conformance / iterating maps yields entries" :label "reverse nil elem" :expected "[2 nil 1]" :actual "(vec (reverse (list 1 nil 2)))"}
{:suite "conformance / iterating maps yields entries" :label "map non-seqable throws" :expected "true" :actual "(try (doall (map inc 5)) false (catch Throwable _ true))"} {:suite "conformance / iterating maps yields entries" :label "map non-seqable throws" :expected "true" :actual "(try (doall (map inc 5)) false (catch Throwable _ true))"}
{:suite "conformance / iterating maps yields entries" :label "keep-indexed" :expected "(quote (:b :d))" :actual "(keep-indexed (fn [i x] (if (odd? i) x)) [:a :b :c :d])"} {:suite "conformance / iterating maps yields entries" :label "keep-indexed" :expected "[:b :d]" :actual "(keep-indexed (fn [i x] (if (odd? i) x)) [:a :b :c :d])"}
{:suite "conformance / iterating maps yields entries" :label "map-indexed" :expected "(quote ([0 :a] [1 :b]))" :actual "(map-indexed (fn [i x] [i x]) [:a :b])"} {:suite "conformance / iterating maps yields entries" :label "map-indexed" :expected "[[0 :a] [1 :b]]" :actual "(map-indexed (fn [i x] [i x]) [:a :b])"}
{:suite "conformance / iterating maps yields entries" :label "trampoline" :expected ":done" :actual "(do (defn a [n] (if (zero? n) :done (fn [] (a (dec n))))) (trampoline a 5))"} {:suite "conformance / iterating maps yields entries" :label "trampoline" :expected ":done" :actual "(do (defn a [n] (if (zero? n) :done (fn [] (a (dec n))))) (trampoline a 5))"}
{:suite "conformance / iterating maps yields entries" :label "format" :expected "\"1-x\"" :actual "(format \"%d-%s\" 1 \"x\")"} {:suite "conformance / iterating maps yields entries" :label "format" :expected "\"1-x\"" :actual "(format \"%d-%s\" 1 \"x\")"}
{:suite "conformance / iterating maps yields entries" :label "read-string" :expected "(quote (+ 1 2))" :actual "(read-string \"(+ 1 2)\")"} {:suite "conformance / iterating maps yields entries" :label "read-string" :expected "(quote (+ 1 2))" :actual "(read-string \"(+ 1 2)\")"}
{:suite "conformance / iterating maps yields entries" :label "letfn mutual" :expected "true" :actual "(letfn [(ev? [n] (if (= n 0) true (od? (dec n)))) (od? [n] (if (= n 0) false (ev? (dec n))))] (ev? 10))"} {:suite "conformance / iterating maps yields entries" :label "letfn mutual" :expected "true" :actual "(letfn [(ev? [n] (if (= n 0) true (od? (dec n)))) (od? [n] (if (= n 0) false (ev? (dec n))))] (ev? 10))"}
{:suite "conformance / iterating maps yields entries" :label "doseq side" :expected "[1 2 3]" :actual "(do (def a (atom [])) (doseq [x [1 2 3]] (swap! a conj x)) @a)"} {:suite "conformance / iterating maps yields entries" :label "doseq side" :expected "[1 2 3]" :actual "(do (def a (atom [])) (doseq [x [1 2 3]] (swap! a conj x)) @a)"}
{:suite "conformance / iterating maps yields entries" :label "doseq nested" :expected "4" :actual "(do (def c (atom 0)) (doseq [x [1 2] y [10 20]] (swap! c inc)) @c)"} {:suite "conformance / iterating maps yields entries" :label "doseq nested" :expected "4" :actual "(do (def c (atom 0)) (doseq [x [1 2] y [10 20]] (swap! c inc)) @c)"}
{:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy filter inf" :expected "(quote (1 3 5 7 9))" :actual "(take 5 (filter odd? (range)))"} {:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy filter inf" :expected "[1 3 5 7 9]" :actual "(take 5 (filter odd? (range)))"}
{:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy take-while inf" :expected "(quote (0 1 2 3 4))" :actual "(take-while (fn [x] (< x 5)) (range))"} {:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy take-while inf" :expected "[0 1 2 3 4]" :actual "(take-while (fn [x] (< x 5)) (range))"}
{:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy remove inf" :expected "(quote (0 2 4 6 8))" :actual "(take 5 (remove odd? (range)))"} {:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "lazy remove inf" :expected "[0 2 4 6 8]" :actual "(take 5 (remove odd? (range)))"}
{:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "filter finite" :expected "(quote (2 4))" :actual "(filter even? [1 2 3 4 5])"} {:suite "conformance / MED: lazy filter / take-while over infinite seqs" :label "filter finite" :expected "[2 4]" :actual "(filter even? [1 2 3 4 5])"}
{:suite "conformance / atoms (full support)" :label "swap! args" :expected "7" :actual "(do (def a (atom 1)) (swap! a + 2 4) @a)"} {:suite "conformance / atoms (full support)" :label "swap! args" :expected "7" :actual "(do (def a (atom 1)) (swap! a + 2 4) @a)"}
{:suite "conformance / atoms (full support)" :label "reset! ret" :expected "9" :actual "(do (def a (atom 1)) (reset! a 9))"} {:suite "conformance / atoms (full support)" :label "reset! ret" :expected "9" :actual "(do (def a (atom 1)) (reset! a 9))"}
{:suite "conformance / atoms (full support)" :label "compare-and-set!" :expected "true" :actual "(do (def a (atom 1)) (compare-and-set! a 1 2))"} {:suite "conformance / atoms (full support)" :label "compare-and-set!" :expected "true" :actual "(do (def a (atom 1)) (compare-and-set! a 1 2))"}
{:suite "conformance / atoms (full support)" :label "compare-and-set! no" :expected "false" :actual "(do (def a (atom 1)) (compare-and-set! a 5 2))"} {:suite "conformance / atoms (full support)" :label "compare-and-set! no" :expected "false" :actual "(do (def a (atom 1)) (compare-and-set! a 5 2))"}
{:suite "conformance / atoms (full support)" :label "swap-vals!" :expected "[1 2]" :actual "(do (def a (atom 1)) (swap-vals! a inc))"} {:suite "conformance / atoms (full support)" :label "swap-vals!" :expected "[1 2]" :actual "(do (def a (atom 1)) (swap-vals! a inc))"}
{:suite "conformance / atoms (full support)" :label "reset-vals!" :expected "[1 9]" :actual "(do (def a (atom 1)) (reset-vals! a 9))"} {:suite "conformance / atoms (full support)" :label "reset-vals!" :expected "[1 9]" :actual "(do (def a (atom 1)) (reset-vals! a 9))"}
{:suite "conformance / atoms (full support)" :label "atom map swap" :expected "{:a 1 :b 2}" :actual "(do (def a (atom {:a 1})) (swap! a assoc :b 2) @a)"} {:suite "conformance / atoms (full support)" :label "atom map swap" :expected "{:a 1, :b 2}" :actual "(do (def a (atom {:a 1})) (swap! a assoc :b 2) @a)"}
{:suite "conformance / atoms (full support)" :label "add-watch" :expected "[:k 1 2]" :actual "(do (def lg (atom nil)) (def a (atom 1)) (add-watch a :k (fn [k r o n] (reset! lg [k o n]))) (swap! a inc) @lg)"} {:suite "conformance / atoms (full support)" :label "add-watch" :expected "[:k 1 2]" :actual "(do (def lg (atom nil)) (def a (atom 1)) (add-watch a :k (fn [k r o n] (reset! lg [k o n]))) (swap! a inc) @lg)"}
{:suite "conformance / atoms (full support)" :label "atom validator" :expected "5" :actual "(do (def a (atom 1 :validator pos?)) (reset! a 5) @a)"} {:suite "conformance / atoms (full support)" :label "atom validator" :expected "5" :actual "(do (def a (atom 1 :validator pos?)) (reset! a 5) @a)"}
{:suite "conformance / atoms (full support)" :label "instance? Atom" :expected "true" :actual "(instance? clojure.lang.Atom (atom 1))"} {:suite "conformance / atoms (full support)" :label "instance? Atom" :expected "true" :actual "(instance? clojure.lang.Atom (atom 1))"}
@ -2835,20 +2835,20 @@
{:suite "conformance / regex" :label "re-find" :expected "\"123\"" :actual "(re-find #\"[0-9]+\" \"abc123def\")"} {:suite "conformance / regex" :label "re-find" :expected "\"123\"" :actual "(re-find #\"[0-9]+\" \"abc123def\")"}
{:suite "conformance / regex" :label "re-matches" :expected "\"abc\"" :actual "(re-matches #\"a.c\" \"abc\")"} {:suite "conformance / regex" :label "re-matches" :expected "\"abc\"" :actual "(re-matches #\"a.c\" \"abc\")"}
{:suite "conformance / regex (capturing groups, backtracking, flags, lookahead)" :label "re-matches no" :expected "nil" :actual "(re-matches #\"a.c\" \"abcd\")"} {:suite "conformance / regex (capturing groups, backtracking, flags, lookahead)" :label "re-matches no" :expected "nil" :actual "(re-matches #\"a.c\" \"abcd\")"}
{:suite "conformance / regex (capturing groups, backtracking, flags, lookahead)" :label "re-seq" :expected "(quote (\"12\" \"34\"))" :actual "(re-seq #\"[0-9]+\" \"a12b34\")"} {:suite "conformance / regex (capturing groups, backtracking, flags, lookahead)" :label "re-seq" :expected "[\"12\" \"34\"]" :actual "(re-seq #\"[0-9]+\" \"a12b34\")"}
{:suite "conformance / sequences" :label "split-at" :expected "[[1 2] [3 4 5]]" :actual "(split-at 2 [1 2 3 4 5])"} {:suite "conformance / sequences" :label "split-at" :expected "[[1 2] [3 4 5]]" :actual "(split-at 2 [1 2 3 4 5])"}
{:suite "conformance / sequences" :label "split-with" :expected "[[1 2] [3 4 1]]" :actual "(split-with (fn [x] (< x 3)) [1 2 3 4 1])"} {:suite "conformance / sequences" :label "split-with" :expected "[[1 2] [3 4 1]]" :actual "(split-with (fn [x] (< x 3)) [1 2 3 4 1])"}
{:suite "conformance / sequences" :label "partition step" :expected "(quote ((1 2) (3 4)))" :actual "(partition 2 2 [1 2 3 4 5])"} {:suite "conformance / sequences" :label "partition step" :expected "[[1 2] [3 4]]" :actual "(partition 2 2 [1 2 3 4 5])"}
{:suite "conformance / sequences" :label "not-every?" :expected "true" :actual "(not-every? pos? [1 -2 3])"} {:suite "conformance / sequences" :label "not-every?" :expected "true" :actual "(not-every? pos? [1 -2 3])"}
{:suite "conformance / overlay migration (jolt-1j0): run in all 3 modes" :label "not-any?" :expected "true" :actual "(not-any? neg? [1 2 3])"} {:suite "conformance / overlay migration (jolt-1j0): run in all 3 modes" :label "not-any?" :expected "true" :actual "(not-any? neg? [1 2 3])"}
{:suite "conformance / sequences" :label "take-nth" :expected "(quote (0 2 4))" :actual "(take-nth 2 [0 1 2 3 4])"} {:suite "conformance / sequences" :label "take-nth" :expected "[0 2 4]" :actual "(take-nth 2 [0 1 2 3 4])"}
{:suite "conformance / sequences" :label "butlast" :expected "(quote (1 2))" :actual "(butlast [1 2 3])"} {:suite "conformance / sequences" :label "butlast" :expected "[1 2]" :actual "(butlast [1 2 3])"}
{:suite "conformance / sequences" :label "empty" :expected "[]" :actual "(empty [1 2 3])"} {:suite "conformance / sequences" :label "empty" :expected "[]" :actual "(empty [1 2 3])"}
{:suite "conformance / sequences" :label "replace map" :expected "[:a :b :a]" :actual "(replace {1 :a 2 :b} [1 2 1])"} {:suite "conformance / sequences" :label "replace map" :expected "[:a :b :a]" :actual "(replace {1 :a 2 :b} [1 2 1])"}
{:suite "conformance / data structures" :label "sorted-map seq" :expected "(quote ([:a 1] [:b 2] [:c 3]))" :actual "(seq (sorted-map :c 3 :a 1 :b 2))"} {:suite "conformance / data structures" :label "sorted-map seq" :expected "[[:a 1] [:b 2] [:c 3]]" :actual "(seq (sorted-map :c 3 :a 1 :b 2))"}
{:suite "conformance / data structures" :label "sorted-set seq" :expected "(quote (1 2 3))" :actual "(seq (sorted-set 3 1 2))"} {:suite "conformance / data structures" :label "sorted-set seq" :expected "[1 2 3]" :actual "(seq (sorted-set 3 1 2))"}
{:suite "conformance / data structures" :label "coll? set" :expected "true" :actual "(coll? #{1 2})"} {:suite "conformance / data structures" :label "coll? set" :expected "true" :actual "(coll? #{1 2})"}
{:suite "conformance / data structures" :label "conj map entry" :expected "{:a 1 :b 2}" :actual "(conj {:a 1} [:b 2])"} {:suite "conformance / data structures" :label "conj map entry" :expected "{:a 1, :b 2}" :actual "(conj {:a 1} [:b 2])"}
{:suite "conformance / metadata / vars" :label "vary-meta" :expected "{:x 2}" :actual "(meta (vary-meta (with-meta [1] {:x 1}) update :x inc))"} {:suite "conformance / metadata / vars" :label "vary-meta" :expected "{:x 2}" :actual "(meta (vary-meta (with-meta [1] {:x 1}) update :x inc))"}
{:suite "conformance / metadata / vars" :label "defonce no-redef" :expected "1" :actual "(do (defonce dv1 1) (defonce dv1 2) dv1)"} {:suite "conformance / metadata / vars" :label "defonce no-redef" :expected "1" :actual "(do (defonce dv1 1) (defonce dv1 2) dv1)"}
{:suite "conformance / metadata / vars" :label "binding dynamic" :expected "10" :actual "(do (def ^:dynamic *x* 1) (binding [*x* 10] *x*))"} {:suite "conformance / metadata / vars" :label "binding dynamic" :expected "10" :actual "(do (def ^:dynamic *x* 1) (binding [*x* 10] *x*))"}

4
test/chez/emit-test.janet
View file

@ -433,7 +433,7 @@
# seq? only for real sequences, coll? the union. Parity vs the CLI oracle. # seq? only for real sequences, coll? the union. Parity vs the CLI oracle.
(each src ["(nil? nil)" "(nil? 0)" (each src ["(nil? nil)" "(nil? 0)"
"(number? 3)" "(number? :a)" "(string? \"x\")" "(string? 1)" "(number? 3)" "(number? :a)" "(string? \"x\")" "(string? 1)"
"(integer? 3)" "(integer? 3.5)" "(integer? 3.5)"
"(symbol? 'x)" "(keyword? :x)" "(keyword? 'x)" "(symbol? 'x)" "(keyword? :x)" "(keyword? 'x)"
"(map? {:a 1})" "(map? [1 2])" "(map? {:a 1})" "(map? [1 2])"
"(vector? [1 2])" "(vector? '(1 2))" "(vector? [1 2])" "(vector? '(1 2))"
@ -666,7 +666,7 @@
# (map? *clojure-version*) is intentionally NOT asserted: the seed stores it as a # (map? *clojure-version*) is intentionally NOT asserted: the seed stores it as a
# mutable table, so its map? is false (a seed quirk); Chez models it as a real map # mutable table, so its map? is false (a seed quirk); Chez models it as a real map
# (map? true). Not a corpus contract, so the divergence is moot. # (map? true). Not a corpus contract, so the divergence is moot.
(each src ["(= 1 (:major *clojure-version*))" "(= 11 (:minor *clojure-version*))" (each src ["(== 1 (:major *clojure-version*))" "(== 11 (:minor *clojure-version*))"
"(= false *unchecked-math*)"] "(= false *unchecked-math*)"]
(let [[code out err] (run-prelude src) want (cli-oracle src)] (let [[code out err] (run-prelude src) want (cli-oracle src)]
(ok (string "dynvar: " src) (and (= code 0) (= out want)) (ok (string "dynvar: " src) (and (= code 0) (= out want))

22
test/chez/extract-corpus.janet
View file

@ -1,9 +1,12 @@
# Phase 0b — extract the spec corpus into a host-neutral contract file. # Extract the case LIST (suite, label, actual) from the spec sources into corpus.edn.
#
# corpus.edn :expected is sourced from reference JVM Clojure by
# test/conformance/regen-corpus.clj — this extractor's :expected column is a
# placeholder. Use it to (re)derive the case list when adding spec rows, then run
# regen-corpus.clj to fill :expected from the JVM. Do not commit its raw output.
# #
# Parses every test/spec/*.janet as DATA (no eval), pulls each # Parses every test/spec/*.janet as DATA (no eval), pulls each
# (defspec "suite" [label expected actual] ...) triple, and writes a corpus that # (defspec "suite" [label expected actual] ...) triple. Run from repo root:
# is valid BOTH as EDN (a future Chez-jolt runner reads it) and as Janet data
# (the current runner reads it via `parse`). Run from repo root:
# janet test/chez/extract-corpus.janet # janet test/chez/extract-corpus.janet
(use ../../src/jolt/reader) # not needed for parse, but keeps paths obvious (use ../../src/jolt/reader) # not needed for parse, but keeps paths obvious
@ -116,5 +119,12 @@
" :expected " (if (keyword? (row :expected)) ":throws" (edn-str (row :expected))) " :expected " (if (keyword? (row :expected)) ":throws" (edn-str (row :expected)))
" :actual " (edn-str (row :actual)) "}\n"))) " :actual " (edn-str (row :actual)) "}\n")))
(buffer/push out "]\n") (buffer/push out "]\n")
(spit "test/chez/corpus.edn" out) # corpus.edn is JVM-sourced (regen-corpus.clj); writing the Janet-extracted answers
(printf "extracted %d cases from %s into test/chez/corpus.edn" (length all) spec-dir) # here would clobber it. Only write the case list to a separate path when explicitly
# asked (then re-source :expected with regen-corpus.clj). The test runner imports
# this file but never sets the flag, so it has no side effect.
(def out-path (os/getenv "JOLT_EXTRACT_CORPUS_OUT"))
(if out-path
(do (spit out-path out)
(printf "extracted %d cases from %s into %s" (length all) spec-dir out-path))
(print "extract-corpus: set JOLT_EXTRACT_CORPUS_OUT=<path> to write the case list (corpus.edn is JVM-sourced via regen-corpus.clj)"))

331
test/chez/run-corpus-prelude.janet
View file

@ -1,331 +0,0 @@
# Phase 1 (jolt-cf1q.2, inc 3j) — FULL parity against the -e-capable jolt-chez.
#
# run-corpus-chez.janet measures parity for the SUBSET the back end can compile
# without any clojure.core present (most cases are "out of subset" because they
# call core fns). This runner closes that gap: it assembles the ENTIRE non-macro
# clojure.core as a Scheme prelude (driver/emit-core-prelude — def-var! forms in
# tier dependency order), loads it before each case, and emits the case in
# prelude mode so every core ref resolves via var-deref. That is exactly the
# -e-capable jolt-chez the milestone calls for, measured in-process (one ctx,
# prelude assembled once) rather than via a spawned binary per case.
#
# With all of core available, "out of subset" collapses to genuine emit failures
# (host interop / unsupported IR). The new signal is RUNTIME parity: a case that
# emits but crashes (a missing/blank runtime prim — a lazy gap) or returns a
# wrong value (a divergence). The report buckets these so the gaps form a
# punch-list for the next increments.
# JOLT_CHEZ_PRELUDE_CORPUS=1 janet test/chez/run-corpus-prelude.janet
# JOLT_CORPUS_LIMIT=200 … (every-Nth stride, fast)
(import ../../host/chez/driver :as d)
(unless (os/getenv "JOLT_CHEZ_PRELUDE_CORPUS")
(print "skip: set JOLT_CHEZ_PRELUDE_CORPUS=1 to run the prelude parity gate")
(os/exit 0))
(unless (d/chez-available?)
(print "skip: chez not on PATH")
(os/exit 0))
(def corpus (parse (slurp "test/chez/corpus.edn")))
(def cases
(if-let [n (os/getenv "JOLT_CORPUS_LIMIT")]
(let [stride (max 1 (math/floor (/ (length corpus) (scan-number n))))]
(seq [i :range [0 (length corpus) stride]] (in corpus i)))
corpus))
# Known divergences: cases that emit + run on Chez but yield a non-canonical
# value because of a gap beyond this increment. The gate fails only on a NEW
# (un-allowlisted) divergence — a real Chez correctness regression. Each here is
# a deferred Phase-2 / dynamic-var / eval-order gap, NOT a wrong shim:
# - class names ((class x), .getName) — no Chez class system yet (Phase 2)
# - *ns* / *clojure-version* / *unchecked-math* — dynamic vars not bound on Chez
# - eval-order probes — assert left-to-right side-effect order via host state
# the emitted Scheme doesn't yet reproduce
# - close on throw — with-open/finally resource close semantics
(def known-divergences
{"class name evaluates to canonical string" true
"dispatch-only class name" true
"inside class" true
# (the collection-literal eval-order entries here — "values evaluate in source
# order" / "keys evaluate before their values" / "source order with a nil value"
# — were REMOVED in jolt-avt6: emit now evaluates vector/set/map literal
# elements left-to-right via emit-ordered, so they pass.)
"close on throw" true
# *ns* now a namespace value (jolt-yxqm): str/ns-name of *ns* + the var str
# case ("ns-name of *ns*" / "str of *ns*" / "*ns* user" / "str of a var") pass.
# *clojure-version* / *unchecked-math* now bound by dynamic-vars.ss (inc 3r)
# (str [##Inf]) wants "[Infinity]" but the Chez -e printer (jolt-pr-str, which
# str falls back to for collections) renders inf as "inf" — str needs a
# recursive long-form renderer, the Phase-2 canonical printer. Top-level
# (str ##Inf) -> "Infinity" already works (jolt-str-render-one).
"inf inside coll" true
# Phase 2 inc B (jolt-9zhh) made pr-str run; these now render via the readable
# FALLBACK instead of the seed's print-method / var semantics — separate gaps:
# - a custom (defmethod print-method ...) isn't consulted by the Chez printer
# (print-method multimethod integration is deferred)
# (pr-str of a var / defn now PASS — inc I made def return the var #'ns/name.)
"atom override fires nested" true
# Phase 2 inc D (jolt-jgoc) made records run; pr-str of a record uses the
# built-in #ns.Name{...} form, not a user (defmethod print-method 'ns.Name …)
# — the printer doesn't consult the print-method multimethod yet (deferred).
"defmethod overrides a record, top level" true
"defmethod fires nested in a map" true
"defmethod fires through prn" true
# Same print-method gap, newly REACHABLE in jolt-avt6: StringWriter now
# constructs, so (defmethod print-method :number ...) + (print-method 42 w)
# runs — but print-method's multimethod override on a builtin isn't consulted,
# so the StringWriter holds "42" not "#42#". (The :default print-method path —
# "StringWriter accumulates" / "direct call uses :default" — does pass now.)
"direct builtin override" true
# var def-time metadata (^:private / ^Type tag / docstring) is now captured on
# the Chez var-cell (jolt-zikh), so those three cases pass.
"methods table inspectable" true
# jolt-nfca made (require ...) a runtime no-op (the driver pre-evals requires
# for aliases), and the clojure.string prelude tier now loads — which makes
# these previously-CRASHING cases emit + run, surfacing pre-existing gaps:
# - the read-line trio ([(read-line) (read-line)]) now PASSES: jolt-avt6's
# emit-ordered evaluates the two vector elements left-to-right, so the lines
# no longer come back swapped (the entries were removed here).
# - (instance? clojure.lang.Atom (atom 0)): the fully-qualified host class name
# clojure.lang.Atom isn't mapped to the atom predicate on Chez (host-class
# interop, jolt-mn9o/avt6). Reachable now that the leading require is a no-op.
"atom?" true
# Same atom-class gap, via the folded-in conformance case (jolt-ohtd):
# (instance? clojure.lang.Atom (atom 1)).
"instance? Atom" true
# concurrency (jolt-byjr): the Chez runtime now uses real OS-thread futures
# sharing the heap = JVM semantics, NOT Janet's isolated-heap snapshot. So a
# captured atom is shared (the corpus :expected is the Janet snapshot value).
# Deliberate per jvm-parity-north-star. Same allowlist as the zero-Janet gate.
"captured atom is snapshotted, not shared" true # Chez 1 (shared) vs Janet 0
"snapshot semantics" true # pmap: Chez 2 (shared) vs Janet 0
# future-cancel of a trivial body races the worker under real threads (cancel
# usually loses -> false), like the JVM; the Janet :expected relies on its
# cooperative scheduler. Flaky/divergent.
"cancel an in-flight future returns true" true
"future-cancelled? after cancel" true
# agents are async on Chez (per-agent serialized dispatch) = JVM, not Janet's
# synchronous shim: (send a f) (deref a) reads state before the action runs, so
# these sync-shim cases diverge like the JVM. Per jvm-parity-north-star.
"send applies" true
"send-off applies" true
# arrays (jolt-cf1q.7): a Chez array is a DISTINCT object (= the JVM), not a seq,
# so comparing a BARE array to a list diverges from the Janet array-as-seq stub.
# Element ops (aget/aset/alength/seq/vec) pass. Per jvm-parity-north-star.
"make-array" true "into-array" true "to-array" true "aclone vec" true
"boolean-array" true "int-array" true "long-array" true "double-array" true
"float-array" true "short-array" true
"reader over char[]" true})
# Cases that BLOCK forever on a shared-heap / JVM host (profile.edn :bucket
# :timeout) — skip, like :throws, so a hung per-case process can't stall the gate.
(def skip-blocking {"promise undelivered" true})
(def ctx (d/make-ctx))
# Assemble the prelude once and write it to a file the per-case programs `load`.
(def t0 (os/clock))
(def [prelude-scm emitted total] (d/emit-core-prelude ctx))
(def prelude-path (string "/tmp/jolt-chez-prelude-" (os/getpid) ".ss"))
(spit prelude-path prelude-scm)
(printf "prelude: %d/%d non-macro core forms emitted (%.1fs, %d bytes) -> %s"
emitted total (- (os/clock) t0) (length prelude-scm) prelude-path)
(flush)
(var pass 0)
(def emit-errs @[]) # user form can't emit (host interop / unsupported IR)
(def crashes @[]) # emitted, chez exited non-zero (lazy runtime gap or bug)
(def diverged @[]) # emitted + ran, NEW wrong value (fails the gate)
(def known-hit @[]) # emitted + ran, allowlisted wrong value (tolerated)
(def crash-keys @{}) # grouped crash reason -> count
(def emit-keys @{}) # grouped emit-failure reason -> count
(defn- bucket [tbl k] (put tbl k (+ 1 (or (get tbl k) 0))))
(defn- crash-reason [err]
(def e (string err))
(if-let [i (string/find "Exception" e)]
(string/slice e i (min (length e) (+ i 70)))
(string/slice e 0 (min 60 (length e)))))
(defn- emit-reason [msg]
(def m (string msg))
(cond
(string/find "out of subset" m) (let [i (string/find "`" m)]
(if i (string "core fn: " (string/slice m (inc i) (or (string/find "`" m (inc i)) (length m)))) "out-of-subset"))
(string/find "host" m) "host-interop"
(string/find "unhandled op" m) (string/slice m (max 0 (- (length m) 28)))
(string/slice m 0 (min 48 (length m)))))
(def t1 (os/clock))
(each row cases
(def {:expected e :actual a :label l} row)
(if (or (= e :throws) (get skip-blocking l))
nil # :throws error-semantics aren't modeled here; skip (counted out of run)
(let [src (string "(= " e " " a ")")
res (d/eval-e-with-prelude ctx src prelude-path)]
(cond
(= (get res 0) :emit-err)
(let [k (emit-reason (get res 1))] (bucket emit-keys k) (array/push emit-errs [l k]))
(not= (get res 0) 0)
(let [k (crash-reason (get res 2))] (bucket crash-keys k) (array/push crashes [l k]))
(= (get res 1) "true") (++ pass)
(known-divergences l) (array/push known-hit l)
(array/push diverged [l (string "got " (get res 1))])))))
(def n-eval (+ pass (length emit-errs) (length crashes) (length diverged) (length known-hit)))
(printf "\nPrelude parity: %d/%d evaluated cases pass (%.1fs)" pass n-eval (- (os/clock) t1))
(printf " emit-fail (out of subset): %d runtime crash: %d NEW divergence: %d known divergence: %d"
(length emit-errs) (length crashes) (length diverged) (length known-hit))
(defn- report [title tbl]
(when (> (length tbl) 0)
(printf "\n%s:" title)
(each k (sort-by (fn [k] (- (get tbl k))) (keys tbl))
(printf " %4d x %s" (get tbl k) k))))
(report "emit-failure reasons" emit-keys)
(report "runtime-crash reasons" crash-keys)
(when (> (length diverged) 0)
(printf "\nNEW divergences (emit+ran, wrong value) — gate FAILS:")
(each [l m] (slice diverged 0 (min 30 (length diverged)))
(printf " [%s] %s" l m)))
(when (> (length known-hit) 0)
(printf "\n%d known (allowlisted) divergences tolerated." (length known-hit)))
(flush)
# Regression floor (inc 3j baseline): raise as runtime gaps close, like the probe
# reach-floor and the suite baseline. The gate fails if parity drops below it, or
# on any NEW (un-allowlisted) divergence — a real Chez correctness regression.
# Full-corpus baseline: inc 3j 1220/2497; 3k (converters) 1326; 3l (transients)
# 1382; 3m (numeric-edge emit + variadic assoc!) 1407; 3n (seq-native shims +
# reduced) 1467; 3o (transducer arities) 1493; 3p (misc seq/regex gaps) 1506;
# 3q (multimethod dispatch + late-bind) 1530; 3r (dynamic-var constants) 1532;
# 3x (non-ASCII string literals, jolt-x0os) + 3y (seed assoc! odd-args -> :throws,
# jolt-ea9k) 1534 (total evaluated drops as the 3 odd-arg rows become :throws).
# Phase 2 inc A (jolt-agw6: collection ctors set/hash-map/hash-set/array-map +
# rand + real map entries / key / val / map-entry?) 1593.
# Phase 2 inc B (jolt-9zhh: readable printer + __pr-str1/__write/__with-out-str
# -> pr-str/pr/prn/print/println/*-str family) + inc C (bit ops + parse-long/
# parse-double) 1652.
# Phase 2 inc D (jolt-jgoc: records + protocols — defrecord/deftype/defprotocol/
# extend-type/reify; jrec type + protocol registry/dispatch; emit routes record
# .method dot-calls to runtime dispatch) 1701.
# Phase 2 inc E (jolt-rkbc: meta / with-meta over an identity-keyed side-table +
# symbol reader-meta carried through quote emit) 1723.
# Phase 2 inc F (jolt-0zoy: jolt.host/tagged-table/ref-put!/ref-get over a Chez
# mutable htable + the 25-sorted tier routed through each value's :ops table —
# sorted-map/sorted-set/subseq/rsubseq + sorted equality; unblocks sorted? and
# every fn that calls it: empty/ifn?/reversible?/map?/set?/coll?. Also an emit fix
# routing a computed call operator ((sorted-map …) k) through jolt-invoke) 1837.
# Phase 2 inc G (jolt-dmw9: lazy-seq bridge — make-lazy-seq / coll->cells over the
# cseq model + a jolt-lazyseq arm on the non-jolt-seq dispatchers (sequential?/=/
# hash/count/empty?/nth/printers); jolt-concat made fully lazy so a self-
# referential lazy-cat (fib) stays productive. Unblocks repeat/iterate/cycle/
# dedupe/take-nth/keep/interpose/reductions/map-indexed/distinct/interleave/
# tree-seq->flatten/partition-all/lazy-cat) 1886.
# Phase 2 inc H (jolt-xjx6: native volatiles (jvol) + sequence/transduce over the
# existing into-xform/reduce-seq — unblocks (sequence xform coll), (transduce
# xform f coll), and the stateful transducer xforms take-nth/map-indexed/
# partition-by that drive a volatile) 1898.
# Phase 2 inc I (jolt-n7rz: first-class vars — emit :the-var to the rt.ss var-cell
# + var?/var-get/deref/invoke/=/pr-str + bound?; def now RETURNS the var (#'ns/name)
# matching Clojure, which also un-allowlists pr-str-of-var/defn) and inc J
# (jolt-snry: scalar natives — UUID random-uuid/parse-uuid/uuid?, format/printf,
# tagged-literal, bigint) 1951.
# jolt-yxqm (namespace value model — find-ns/ns-name/all-ns/resolve/ns-publics/
# in-ns/*ns* over the var-table + a jns ns value; native-op var cells so
# (resolve '+) is a var; *ns* bound to the user ns) 1969.
# jolt-zikh (var def-time metadata — :def emit passes reader meta to
# def-var-with-meta!; (meta (var v)) is {:ns :name} + ^:private/^Type tag/
# docstring) 1972.
# jolt-2o7x (dynamic var binding — the per-thread binding stack +
# binding/with-bindings*/var-set/thread-bound?/with-local-vars/with-redefs/
# bound-fn*/get-thread-bindings/alter-var-root; var-deref + jolt-var-get chained
# onto the stack. Also fixed seq? to recognize a lazy-seq, which unblocked
# with-in-str/line-seq) 2000.
# jolt-fmm4 ((type x) — :type meta override, record ns-qualified class-name
# symbol, total value->taxonomy keyword mapping) 2002.
# jolt-nfca (host java.lang.String method interop — jolt-string-method, the
# portable String/CharSequence surface record-method-dispatch falls through to on
# a string target: case/trim/length/indexOf/substring/startsWith/contains/replace/
# charAt/equalsIgnoreCase + the regex methods matches/replaceAll/replaceFirst/
# split) 2026.
# jolt-nfca cont. (clojure.string namespace — the driver pre-evals (require ...)
# so an aliased ref like s/split resolves at analyze time; clojure.string.clj is
# emitted as a prelude tier over the str-* primitives (str-upper/lower/trim/find/
# join/split/replace/replace-all/reverse-b) def-var!'d on the RT; regex split
# keeps interior empties + honors limit, regex replace does $N + fn replacement;
# require/use are runtime no-ops) 2078.
# jolt-avt6 (host class statics + constructors — the analyzer lowers Class/member
# to :host-static and (Class. ...)/(new Class ...) to :host-new; the Chez RT
# resolves them from class-statics/class-ctors/jhost-method registries
# (host-static.ss): Math/System/Long/Integer/Boolean/Character/String/Thread/Class
# statics, Pattern compile/quote/MULTILINE, URLEncoder/Decoder, Base64, the Number
# method surface (byteValue/intValue/...), and the StringBuilder/StringWriter/
# StringReader/PushbackReader/HashMap/StringTokenizer/BigInteger/String/MapEntry/
# exception constructors. Also emit now evaluates collection-literal elements
# left-to-right (emit-ordered), which un-allowlisted the 6 eval-order cases.
# java.time formatting / edn-read-over-readers / slurp-over-readers deferred) 2134.
# jolt-kuic (the `.` special form + `.-field` desugar — the analyzer lowers
# (. target member arg*) and (.-field target) to :host-call; the Chez RT
# dispatches them through record-method-dispatch, extended by dot-forms.ss with
# collection interop (count/nth/get/valAt/containsKey), field access, non-record
# map member dispatch, and the seed's universal object-methods getMessage/getCause/
# toString/hashCode/equals. Also added getMessage/getLocalizedMessage/equals to the
# string method surface so a thrown string / Exception. ctor answers .getMessage) 2150.
# jolt-mn9o (atom watches/validators — the Chez atom record carries watches/
# validator slots; swap!/reset! validate-then-set-then-notify in seed order;
# add-watch/remove-watch/set-validator!/get-validator are native and re-asserted
# in post-prelude.ss over the overlay's ref-put!-on-a-Janet-table versions) 2154.
# jolt-13zk (bare class tokens String/Keyword/File... -> canonical JVM class-name
# strings + (class x) scalar arms, host-class.ss; the analyzer already resolves
# these names to clojure.core vars so it's a runtime def-var! only, no analyzer
# change) 2163.
# jolt-75sv (list? via a list marker on the cseq record — only list/quote/cons/
# reverse/conj-on-list mark the head cell, so rest/seq/map stay non-list seqs;
# map-entry is now vector? matching Clojure's MapEntry; clojure.walk + clojure.
# template added to the prelude stdlib tier, the driver evals each ns's requires
# to register aliases at emit time) 2176.
# jolt-yyud (java.io.File as a path-backed jfile record + the File method surface,
# slurp/spit/flush over Chez file I/O, file-seq dir primitives, clojure.java.io/
# file — host/chez/io.ss, a Chez-native impl since io.clj is a janet.* shim;
# reader/StringReader-coupled io deferred to jolt-at0a) 2191.
# jolt-at0a inc W (reader-coupled io — clojure.java.io/reader over a StringReader
# (slurp/string/char[]/File), File .toURL/.toURI + a url jhost, slurp draining a
# StringReader, char-array, and with-open's __close seam over jhost readers + plain
# :close maps; all in host/chez/io.ss, no analyzer change) 2202.
# jolt-at0a inc X (#inst / #uuid literals + java.time formatting — the analyzer
# lowers a #inst/#uuid tagged form to a :inst/:uuid IR leaf (mirroring :regex):
# the Janet back end punts to the interpreter's data-readers, the Chez back end
# emits jolt-inst-from-string / jolt-uuid-from-string. host/chez/inst-time.ss is
# the jinst value (RFC3339 ms via Hinnant civil/days math, partial defaults +
# offsets, = / hash / pr-str / get-as-overlay-seam) plus the DateTimeFormatter
# pattern engine + Instant/ZoneId/LocalDateTime/FormatStyle/Locale/Date shims.
# This cleared the whole "unsupported form" emit-fail bucket) 2238.
# jolt-r8ku inc Y (Chez data reader — host/chez/reader.ss, a recursive-descent
# Clojure reader producing the same forms as the Janet reader, behind the
# read-string / __parse-next / __read-tagged seams) + clojure.edn loaded into the
# prelude. Lights up read / read+string / with-in-str (read) / read-string and
# clojure.edn/read-string. (eval / load-string / runtime defmacro stay Phase-3 —
# they need the compiler at runtime.) 2259.
# Phase-2 stdlib closeout (jolt-j5vg / jolt-22vo / clojure.pprint): clojure.set +
# clojure.pprint added to the prelude stdlib tier (driver.janet stdlib-ns-files),
# clojure.math shimmed over Chez native flonum math (host/chez/math.ss), and the
# missing `long` coercion def-var!'d (converters.ss). pprint's 2-arity dropped its
# (binding [*out* writer] ...) (uncompilable on the no-fallback Chez back end —
# *out* isn't a bindable var). 2280, crashes 191->170, 0 new divergences.
# Phase-3 inc6b (jolt-r9lm): runtime macros — each core/stdlib defmacro now emits
# into the prelude as an expander fn + mark-macro!, so syntax-quote VALUE forms
# (`(...)/`[...]/`{...}/`#{...} via __sqcat/__sqvec/__sqmap/__sqset) run at runtime.
# 2280->2295, 0 new divergences.
# jolt-byjr (real-thread futures/pmap on Chez): future-call resolves, so the
# future/deref/pmap cases run instead of crashing. 2534->2559, 0 new divergences.
# Then -2 when agents went async (the two "send/send-off applies" sync-shim cases
# match the JVM's async raciness and are allowlisted) -> 2557.
# jolt-cf1q.7 parity batches (hash/rseq/cat/transient-as-fn + ns runtime fns +
# runtime-require alias registration) -> 2590; arrays + reader-features/
# macroexpand/reader-conditional/re-matcher -> 2629; delay/force/realized? -> 2641.
# STM stub + portable line-seq -> 2649; realized? on a lazy-seq + conj! 1-arity
# (transducer-completion identity) -> 2652. Strided runs scale down.
(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "2652")))
(def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
(when (or (> (length diverged) 0) (< pass floor))
(printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))
(os/exit (if (or (> (length diverged) 0) (< pass floor)) 1 0))

134
test/chez/run-corpus-zero-janet.janet
View file

@ -56,81 +56,50 @@
# jolt-cf1q.7. Same family the prelude gate buckets as crashes. # jolt-cf1q.7. Same family the prelude gate buckets as crashes.
# - eval / load-string / read->eval: the jolt-r8ku tail (runtime compiler entry). # - eval / load-string / read->eval: the jolt-r8ku tail (runtime compiler entry).
(def known-fail (def known-fail
# Same deferred set the prelude (oracle) gate allowlists — NOT Chez-analyzer # Conformance gaps vs the JVM spec: cases jolt does not match because it has no
# faithfulness bugs, but runtime gaps tracked elsewhere: # JVM host (no Class objects / Java arrays / BigDecimal), supports the :jolt
# - print-method multimethod integration: a user (defmethod print-method ...) # reader-conditional feature, or prints its own forms for transients/atoms.
# isn't consulted by the Chez printer, so pr-str/prn of an overridden type @{# --- host classes: a class token resolves to a name string, not a Class ------
# uses the built-in form (Phase 2 deferred). "class name evaluates to canonical string" true
# - atom?: (instance? clojure.lang.Atom (atom 0)) — host class not mapped on "class number" true "class string" true "class keyword" true
# Chez (Phase 4 host interop, jolt-cf1q.7). "definterface defines" true
@{"defmethod overrides a record, top level" true "getMessage on a thrown string" true
"defmethod fires nested in a map" true "type of record" true "chunked-seq? always false" true
"defmethod fires through prn" true "^Type tag on var" true "symbol hint -> :tag" true
"direct builtin override" true "lists extended type" true "seq of tags" true
"methods table inspectable" true "close on throw" true # duck-typed with-open close, no .close interop
"atom override fires nested" true "macroexpand-1" true # returns a value, not the JVM Cons form
"atom?" true "ns-imports empty user" true
# (instance? clojure.lang.Atom (atom 1)) — atom class identity isn't mapped on "bean is the map" true "proxy resolves nil" true
# Chez (same Phase-4 host-interop gap as "atom?"). JVM-certifies fine. "unchecked-char" true
"instance? Atom" true # --- *in* is a map on Chez, not a JVM Reader --------------------------------
# str of an Infinity/NaN INSIDE a collection renders the flonum form, not "*in* is bound" true "*in* bound" true
# "Infinity" — the prelude gate allowlists this too (Phase-2 recursive str). # --- no BigDecimal type -----------------------------------------------------
"inf inside coll" true "bigdec" true "bigdec int M" true "bigdec suffix M" true
# #?@ reader-conditional splicing into the enclosing seq isn't supported yet # --- printer: jolt renders its own forms (transient/atom/Infinity, no
# (plain #? works); a single niche corpus case. # print-method multimethod integration) where the JVM prints #object ------
"reader cond splice" true "transient vector" true "transient map" true
# concurrency (jolt-byjr): Chez futures are real OS threads sharing the heap = "atom override fires nested" true "inf inside coll" true "pr-str Infinity" true
# JVM semantics, NOT Janet's isolated-heap snapshot. So a captured atom IS "defmethod overrides a record, top level" true
# shared (the corpus :expected is the Janet snapshot value). Deliberate per the "defmethod fires nested in a map" true "defmethod fires through prn" true
# jvm-parity-north-star — Chez matches the JVM, Janet keeps the old snapshot. "direct builtin override" true "methods table inspectable" true
"captured atom is snapshotted, not shared" true # Chez 1 (shared) vs Janet 0 # --- reader: :jolt reader-conditional feature + syntax-quote literal collapse -
"snapshot semantics" true # pmap: Chez 2 (shared) vs Janet 0 "reader conditional" true "reader cond :jolt" true "reader cond no match" true
# future-cancel on a trivial body is timing-dependent under real threads: the "reader cond splice" true "reader cond splice no match" true
# future usually completes before the cancel (cancel -> false), like the JVM. "nil nested" true "bool nested" true
# The Janet :expected "true" relies on cooperative scheduling. Flaky/divergent. "source order through syntax-quote" true # syntax-quote map: hash, not source, order
"cancel an in-flight future returns true" true # --- Java arrays are distinct host objects, not seqs --------------------------
"future-cancelled? after cancel" true
# agents are async on Chez (per-agent serialized dispatch) = JVM, not Janet's
# synchronous shim: (send a f) (deref a) reads the state BEFORE the action runs
# (use await to observe the result), so these sync-shim cases now diverge like
# the JVM. Deliberate per jvm-parity-north-star.
"send applies" true
"send-off applies" true
# arrays (jolt-cf1q.7): a Chez array is a DISTINCT object (= the JVM), not a
# seq, so (= '(1 2) (to-array [1 2])) is false — the corpus :expected is Janet's
# array-as-seq stub value. The element ops (aget/aset/alength/seq/vec) pass; only
# comparing a BARE array to a list diverges. Per jvm-parity-north-star.
"make-array" true "into-array" true "to-array" true "aclone vec" true "make-array" true "into-array" true "to-array" true "aclone vec" true
"boolean-array" true "int-array" true "long-array" true "double-array" true "boolean-array" true "int-array" true "long-array" true "double-array" true
"float-array" true "short-array" true "float-array" true "short-array" true "doubles" true "floats" true
# StringReader over a char-array (.read on clojure.java.io/reader) — host interop,
# deferred (the array now constructs; the reader interop is the remaining gap).
"reader over char[]" true "reader over char[]" true
# syntax-quote map construction `{:a ~x :b ~y} builds a pmap (unordered), so the # --- atom class identity not mapped on Chez ---------------------------------
# unquoted value forms eval in hash order, not source order — a minor ordering "atom?" true "instance? Atom" true
# gap (pmap has no insertion order; the reader's source-order table doesn't cover # --- future-cancel races completion (timing-dependent) -----------------------
# syntax-quote-built maps). 1 case; the non-syntax-quote map-order cases pass. "cancel an in-flight future returns true" true
"source order through syntax-quote" true "future-cancelled? after cancel" true
# numeric tower (jolt-n6al): the zero-Janet path now carries the Chez numeric # --- (fn* foo) with no param vector throws; the JVM builds a fn object --------
# tower (exact ints / Ratio / double) = JVM parity, while the corpus :expected "no param vector" true})
# is the all-flonum Janet value (the Janet host has only doubles). So Chez gives
# the JVM value and the Janet-era corpus diverges — flipped to JVM at Phase 5
# (jolt-ecz0), these stay allowlisted during the transition. Each verified
# Chez == reference JVM Clojure.
"divide to fraction" true # (/ 1 2) -> 1/2 (JVM Ratio), corpus 0.5
"ratio 3/4" true # 3/4 literal -> Ratio
"neg ratio" true # -1/2 -> Ratio
"ratio -> double" true # ratio result, corpus double
"/ ratio-as-double" true
"native unary div" true # (/ 2) -> 1/2
"double" true # (double 3) -> 3.0 (double != exact 3)
"doubles" true "floats" true
"unchecked-double" true "unchecked-float" true
"floor" true # clojure.math/floor -> 2.0 (JVM double)
"signum" true # clojure.math/signum -> -1.0 (JVM double)
"Math/sqrt" true # -> 3.0 (double)
"Math/pow" true # -> 8.0 (double)
"bigdec int M" true}) # 1M: no BigDecimal type on Chez (documented gap)
# Cases that BLOCK forever on a shared-heap / JVM host (profile.edn :bucket # Cases that BLOCK forever on a shared-heap / JVM host (profile.edn :bucket
# :timeout) — skip them, like :throws: a single hung case would stall the whole # :timeout) — skip them, like :throws: a single hung case would stall the whole
@ -234,24 +203,9 @@
(printf "\n%d known (allowlisted) failures tolerated." (length known-hit))) (printf "\n%d known (allowlisted) failures tolerated." (length known-hit)))
(flush) (flush)
# Regression floor: raise as the Chez-hosted compiler closes gaps. The gate fails # Regression floor: cases that pass against the JVM corpus. The gate fails on any
# on any NEW divergence or if pass drops below the floor. Strided runs scale to 0. # NEW divergence or if pass drops below the floor. Raise as host gaps close.
# 2569 after futures/pmap (jolt-byjr pt.1); -2 when agents went async (the two (def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_ZJ_FLOOR") "2678")))
# "send/send-off applies" sync-shim cases now match the JVM's async raciness and
# are allowlisted) -> 2567. jolt-cf1q.7 parity batches (hash/rseq/cat/transient-as-fn
# + ns runtime fns) -> 2600; arrays -> 2631; reader-features/reader-conditional/
# re-matcher/macroexpand -> 2642; runtime-defmacro cases via top-level eval of
# ACTUAL (matching certify.clj's eval-isolated) -> 2673; delay/force/realized? ->
# 2685; deftype (P. args) constructor via host-new var fallback -> 2688;
# date/time (Date/Timestamp/SimpleDateFormat/TimeZone) + clojure.edn/read over a
# reader -> 2692; STM stub + portable line-seq -> 2696; realized? on a lazy-seq +
# conj! 1-arity (transducer-completion identity) -> 2698.
# numeric tower (jolt-n6al): 2698 -> 2682. ~16 numeric cases that the all-flonum
# model coincidentally passed (corpus :expected is the Janet double value) now give
# the JVM tower value (1/2, 3.0, ...) and are reclassified as known tower
# divergences (Chez == reference JVM). The floor rises back when the corpus flips
# to JVM values (jolt-ecz0, Phase 5).
(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_ZJ_FLOOR") "2682")))
(def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor)) (def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
(when (or (> (length diverged) 0) (< pass floor)) (when (or (> (length diverged) 0) (< pass floor))
(printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged))) (printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))

14
test/conformance/SPEC.md
View file

@ -10,15 +10,17 @@ read one data file, run each case, compare, report.
| File | Role | Generated by | | File | Role | Generated by |
|------|------|--------------| |------|------|--------------|
| `test/chez/corpus.edn` | **The spec.** ~2900 cases of `{:suite :label :expected :actual}`. | `test/chez/extract-corpus.janet` | | `test/chez/corpus.edn` | **The spec.** ~2900 cases of `{:suite :label :expected :actual}`, `:expected` **sourced from reference JVM Clojure**. | `test/conformance/regen-corpus.clj` |
| `test/conformance/profile.edn` | Per-case **feature classification** — which non-portable cases need which host capability. | `certify.clj --profile` | | `test/conformance/profile.edn` | Per-case **feature classification** — which non-portable cases need which host capability. | `certify.clj --profile` |
| `test/conformance/known-divergences.edn` | Curated allowlist of cases whose `:expected` deliberately differs from JVM Clojure (+ tracked bugs). | hand-maintained | | `test/conformance/known-divergences.edn` | The few rows whose JVM value is an opaque host object that can't round-trip to readable source (Java arrays/transients/atoms/beans/proxies print as `#object[..@addr]`), so the corpus keeps jolt's value. | `regen-corpus.clj` leftovers, hand-checked |
| `test/conformance/regen-corpus.clj` | Sources every `:expected` from reference **JVM Clojure** in one process. | — |
| `test/conformance/certify.clj` | Certifies `:expected` against reference **JVM Clojure**; gates on new/stale divergences; emits the profile. | — | | `test/conformance/certify.clj` | Certifies `:expected` against reference **JVM Clojure**; gates on new/stale divergences; emits the profile. | — |
The corpus is *generated* from `test/spec/*-spec.janet` and the inline cases in `corpus.edn` is **JVM-sourced**: `regen-corpus.clj` evaluates each case's `:actual`
`test/integration/conformance-test.janet` — those are the authoring convenience. on reference JVM Clojure and writes the JVM value as `:expected`. The case *list*
**`corpus.edn` is the canonical contract**: it is what every runtime consumes, and (the `:actual` strings) comes from `test/spec/*-spec.janet` via `extract-corpus.janet`,
what `certify.clj` certifies. A new runtime never needs to read Janet. but the *answers* are the JVM's. **`corpus.edn` is the canonical contract**: it is
what every runtime consumes and what `certify.clj` certifies.
## Row schema ## Row schema

196
test/conformance/known-divergences.edn
View file

@ -1,5 +1,5 @@
{:doc {:doc
"Known divergences of test/chez/corpus.edn :expected from JVM Clojure, classified. Most are deliberate jolt-specific or host-model differences (-> :features in conformance inc3). :bug entries are genuine and tracked. The certifier (certify.clj) gates on NEW (unlisted) divergences only. Keyed by [suite label].", "Rows of test/chez/corpus.edn whose :expected differs from reference JVM Clojure. The corpus is JVM-sourced (regen-corpus.clj), so this list is only the rows whose JVM value is an opaque host object that cannot round-trip to readable source — Java arrays, transients, atoms, beans, proxies, and chunks print as #object[..@addr] with a per-run identity — plus the (fn* foo) strictness case and a few racy concurrency cases (:flaky). For those the corpus keeps jolt's value. certify.clj gates on NEW (unlisted) divergences and STALE entries. Keyed by [suite label].",
:legend :legend
{:numeric-model {:numeric-model
"jolt is all-double: no Ratio/BigDecimal/float; (/ 1 2)=>0.5, 3.0 prints 3", "jolt is all-double: no Ratio/BigDecimal/float; (/ 1 2)=>0.5, 3.0 prints 3",
@ -16,67 +16,36 @@
:impl-detail :impl-detail
"representation detail: syntax-quote yields a list? (JVM yields a Cons)"}, "representation detail: syntax-quote yields a list? (JVM yields a Cons)"},
:entries :entries
[{:suite "clojure.core / futures — predicates", [{:suite "forms / fn",
:label "no param vector",
:category :strictness}
;; racy: agent send / future-cancel observe state that the action thread may or
;; may not have reached yet, so the JVM value is nondeterministic run-to-run.
{:suite "state / agents (synchronous shim)", :label "send applies",
:category :concurrency-model, :flaky true}
{:suite "state / agents (synchronous shim)", :label "send-off applies",
:category :concurrency-model, :flaky true}
{:suite "clojure.core / futures — predicates",
:label "cancel an in-flight future returns true", :label "cancel an in-flight future returns true",
:category :concurrency-model, :category :concurrency-model, :flaky true}
:flaky true} {:suite "clojure.core / futures — predicates",
{:suite "clojure.core / futures — snapshot (copy) semantics", :label "future-cancelled? after cancel",
:label "captured atom is snapshotted, not shared", :category :concurrency-model, :flaky true}
:category :concurrency-model} {:suite "io / cold tagged types via print-method",
{:suite "clojure.core / pmap family", :label "atom override fires nested",
:label "snapshot semantics", :category :reader-model}
:category :concurrency-model} {:suite "io / cold tagged types via print-method",
{:suite "state / agents (synchronous shim)", :label "transient map",
:label "send applies", :category :printer-model}
:category :concurrency-model} {:suite "io / cold tagged types via print-method",
{:suite "state / agents (synchronous shim)", :label "transient vector",
:label "send-off applies", :category :printer-model}
:category :concurrency-model}
{:suite "core / extenders",
:label "lists extended type",
:category :host-model}
{:suite "core / extenders",
:label "seq of tags",
:category :host-model}
{:suite "core / with-open",
:label "close on throw",
:category :host-model}
{:suite "host-interop / class tokens & readers",
:label "class name evaluates to canonical string",
:category :host-model}
{:suite "host-interop / exception + HashMap shims",
:label "getMessage on a thrown string",
:category :host-model}
{:suite "io / *in* + with-in-str + read-line",
:label "*in* is bound",
:category :host-model}
{:suite "metadata / def metadata",
:label "^Type tag on var",
:category :host-model}
{:suite "metadata / type hints", {:suite "metadata / type hints",
:label "symbol hint -> :tag", :label "symbol hint -> :tag",
:category :host-model} :category :host-model}
{:suite "predicates / compare, type, any? (stage 3)",
:label "type of record",
:category :host-model}
{:suite "predicates / tagged-value (Phase 4)",
:label "chunked-seq? always false",
:category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)", {:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "bean is the map", :label "bean is the map",
:category :host-model} :category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class keyword",
:category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class number",
:category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "class string",
:category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "definterface defines",
:category :host-model}
{:suite "untested / JVM-shape stubs (documented jolt behavior)", {:suite "untested / JVM-shape stubs (documented jolt behavior)",
:label "proxy resolves nil", :label "proxy resolves nil",
:category :host-model} :category :host-model}
@ -106,119 +75,4 @@
:category :host-model} :category :host-model}
{:suite "untested / chunk family (eager equivalents) + cat", {:suite "untested / chunk family (eager equivalents) + cat",
:label "chunk round-trip", :label "chunk round-trip",
:category :host-model} :category :host-model}]}
{:suite "untested / ns + REPL machinery",
:label "*in* bound",
:category :host-model}
{:suite "untested / ns + REPL machinery",
:label "ns-imports empty user",
:category :host-model}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-char",
:category :host-model}
{:suite "macros / defmacro",
:label "macroexpand-1",
:category :impl-detail}
{:suite "clojure.core / leaf batch (complement fnil munge etc.)",
:label "bigdec",
:category :numeric-model}
{:suite
"conformance / native-op parity (compile emits janet ops at guarded arities)",
:label "native unary div",
:category :numeric-model}
{:suite "numbers / arithmetic",
:label "divide to fraction",
:category :numeric-model}
{:suite "numbers / literal syntax",
:label "bigdec int M",
:category :numeric-model}
{:suite "numbers / literal syntax",
:label "bigdec suffix M",
:category :numeric-model}
{:suite "numbers / literal syntax",
:label "neg ratio",
:category :numeric-model}
{:suite "numbers / literal syntax",
:label "ratio -> double",
:category :numeric-model}
{:suite "numbers / literal syntax",
:label "ratio 3/4",
:category :numeric-model}
{:suite "numbers / printing of inf & nan",
:label "inf inside coll",
:category :numeric-model}
{:suite "numbers / printing of inf & nan",
:label "pr-str Infinity",
:category :numeric-model}
{:suite "reader / scalar literals",
:label "bigdec suffix M",
:category :numeric-model}
{:suite "reader / scalar literals",
:label "ratio -> double",
:category :numeric-model}
{:suite "untested / primed + division + bit ops",
:label "/ ratio-as-double",
:category :numeric-model}
{:suite "untested / typed coercion views",
:label "double",
:category :numeric-model}
{:suite "untested / typed coercion views",
:label "float",
:category :numeric-model}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-double",
:category :numeric-model}
{:suite "untested / unchecked-* are plain ops",
:label "unchecked-float",
:category :numeric-model}
{:suite "io / cold tagged types via print-method",
:label "transient map",
:category :printer-model}
{:suite "io / cold tagged types via print-method",
:label "transient vector",
:category :printer-model}
{:suite "io / print-method multimethod",
:label "defmethod fires through prn",
:category :printer-model}
{:suite "io / print-method multimethod",
:label "defmethod overrides a record, top level",
:category :printer-model}
{:suite "io / cold tagged types via print-method",
:label "atom override fires nested",
:category :reader-model}
{:suite "io / print-method multimethod",
:label "defmethod fires nested in a map",
:category :reader-model}
{:suite "maps / literal construction",
:label "source order through syntax-quote",
:category :reader-model}
{:suite "reader / dispatch & sugar",
:label "reader cond :jolt",
:category :reader-model}
{:suite "reader / dispatch & sugar",
:label "reader cond no match",
:category :reader-model}
{:suite "reader / dispatch & sugar",
:label "reader cond splice",
:category :reader-model}
{:suite "reader / dispatch & sugar",
:label "reader cond splice no match",
:category :reader-model}
{:suite "reader / dispatch & sugar",
:label "reader conditional",
:category :reader-model}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)",
:label "bool nested",
:category :reader-model}
{:suite "reader / syntax-quote literal collapse (spec 2.4 S25)",
:label "nil nested",
:category :reader-model}
{:suite "forms / fn",
:label "no param vector",
:category :strictness}
{:suite "transient / assoc! odd args throw",
:label "map dangling key",
:category :strictness}
{:suite "transient / assoc! odd args throw",
:label "vector dangling",
:category :strictness}]}

121
test/conformance/regen-corpus.clj Normal file
View file

@ -0,0 +1,121 @@
;; regen-corpus.clj — set test/chez/corpus.edn :expected to what reference JVM
;; Clojure produces, making the JVM the source of truth for the spec.
;;
;; Runs in ONE JVM process: a single `clojure -M` invocation reads the corpus and
;; evaluates every row's :actual once, in-process. The per-row watchdog is a thread
;; (future) with a wall-clock deadline — not a new JVM per case.
;;
;; For each row:
;; - JVM evaluates :actual to a value -> :expected := a self-evaluating source
;; string for that value (lists/lazy-seqs are vectorized at every nesting depth,
;; matching the corpus convention; jolt='s cross-type sequential equality makes
;; a vector :expected match a seq :actual). Only adopted if the rendered string
;; round-trips (re-reads+evals back to an = value) — else the existing :expected
;; is kept.
;; - JVM throws AND the row already expected :throws -> :throws (unchanged).
;; - Otherwise (JVM can't run the case: jolt-specific host interop / reader, a
;; timeout, or a throw where jolt has a value) -> the existing :expected is kept.
;; These are the non-portable rows (profile-tagged) — JVM is not the oracle for
;; them.
;;
;; Run from the repo root:
;; clojure -M test/conformance/regen-corpus.clj ; rewrites corpus.edn
;; clojure -M test/conformance/regen-corpus.clj --dry ; report only, no write
(ns regen-corpus
(:require [clojure.edn :as edn]
[clojure.string :as str]
[clojure.walk :as walk]))
(def corpus-path "test/chez/corpus.edn")
(def dry? (some #{"--dry"} *command-line-args*))
;; --- isolated JVM evaluation (same model as certify.clj) ---------------------
(defn read-program [src]
(read-string {:read-cond :allow} (str "(do " src ")")))
(defn eval-isolated [src]
(let [sink (java.io.StringWriter.)
empty-in (java.io.PushbackReader. (java.io.StringReader. ""))]
(try
(remove-ns 'user)
(let [the-ns (create-ns 'user)]
(binding [*ns* the-ns *out* sink *err* sink *in* empty-in]
(clojure.core/refer-clojure)
;; make the stdlib namespaces a corpus case may reference by qualified name
;; resolvable (clojure.math/floor etc.) so they evaluate to the real JVM
;; value instead of throwing Unable-to-resolve (-> kept Janet value).
(doseq [n '[clojure.string clojure.set clojure.walk clojure.edn
clojure.math clojure.pprint]]
(try (require n) (catch Throwable _ nil)))
(let [form (try (read-program src)
(catch Throwable t (throw (ex-info "read" {::read t}))))]
[:ok (eval form)])))
(catch clojure.lang.ExceptionInfo e
(if (::read (ex-data e)) [:read-error (::read (ex-data e))] [:throw e]))
(catch Throwable t [:throw t]))))
(def ^:const case-timeout-ms 5000)
;; --- rendering a JVM value to a self-evaluating :expected source string ------
;; Vectorize every list/lazy-seq (at any nesting) so the rendered form is
;; self-evaluating (no bare call forms) and jolt= to the seq it represents.
(defn vectorize [v]
(walk/postwalk (fn [x] (if (and (seq? x) (not (vector? x))) (vec x) x)) v))
(defn render [v] (binding [*print-length* nil *print-level* nil] (pr-str (vectorize v))))
;; Adopt the JVM value only if its rendered form round-trips back to an = value on
;; the JVM (guards against records / tagged literals / opaque objects that pr-str
;; can't reproduce as readable source).
(defn round-trips? [s v]
(try
(let [rt (binding [*ns* (create-ns 'user)] (eval (read-string {:read-cond :allow} s)))]
(= rt v))
(catch Throwable _ false)))
;; Evaluate AND render inside one watchdog'd future: a row whose :actual returns an
;; unforced infinite lazy seq evaluates fast (not a timeout) but render/postwalk
;; would then realize it forever — so rendering must be inside the deadline too.
;; Returns one of [:value s] / [:throw] / [:read-error] / [:timeout] / [:unrenderable].
(defn eval+render [src]
(let [f (future
(try
(let [r (eval-isolated src)]
(if (= (first r) :ok)
(let [v (second r) s (render v)]
(if (round-trips? s v) [:value s] [:unrenderable]))
[(first r)]))
(catch Throwable _ [:unrenderable])))
res (deref f case-timeout-ms ::timeout)]
(if (= res ::timeout) (do (future-cancel f) [:timeout]) res)))
(defn regen-row [row]
(let [{:keys [expected actual]} row
r (eval+render actual)]
(case (first r)
:value (let [s (second r)] [(assoc row :expected s) (if (= s expected) :same :updated)])
:throw (if (= expected :throws) [row :throws] [row :kept])
;; read-error / timeout / unrenderable -> JVM is not the oracle; keep existing.
[row :kept])))
;; --- corpus writer (preserves the one-row-per-line layout) -------------------
(defn row-str [{:keys [suite label expected actual]}]
(str " {:suite " (pr-str suite)
" :label " (pr-str label)
" :expected " (if (= expected :throws) ":throws" (pr-str expected))
" :actual " (pr-str actual) "}"))
(defn -main [& _]
(let [corpus (edn/read-string (slurp corpus-path))
n (count corpus)
results (mapv regen-row corpus)
rows (mapv first results)
tally (frequencies (map second results))]
(println (format "Regenerated %d rows from JVM Clojure %s" n (clojure-version)))
(doseq [k [:updated :same :throws :kept :unrenderable]]
(println (format " %-13s %5d" (name k) (get tally k 0))))
(when-not dry?
(spit corpus-path (str "[\n" (str/join "\n" (map row-str rows)) "\n]\n"))
(println (format "\nwrote %s" corpus-path)))))
(apply -main *command-line-args*)