test(suites): convert sort/sort-by, keeping printed-form assertions for NaN

Smell-audited: 1: the NaN cases are the finding. Converting a printed-form
comparison to value equality is usually a strengthening; for NaN it is a
silent break, and the runner caught it.

  phase14_sort.sh  22 spawns -> suites/sort_test.clj

My first draft asserted `(= [1 ##NaN] (into [] (sort [1 ##NaN])))` and failed:

    actual: (not (= [1 ##NaN] [1 ##NaN]))

NaN is not `=` to itself, so that assertion is false whatever sort does — it
could never discriminate. The bash compared printed TEXT, which does. Those
three cases now assert `pr-str` and say why inline, so the next person does
not "improve" them back into value equality.

The rest convert normally: natural-order sorts, explicit comparators,
sort-by projection, the stability case (an all-equal key must preserve input
order), the seq return shape, and the 5000-element scale guard.

Only this file involved NaN among the 19 converted so far; the others assert
over numbers, strings, keywords, chars and quoted forms, where value equality
is both correct and stronger. Every suite passes, which is the evidence.

22 more spawns leave the gate; 673 for the arc across 19 scripts. Suite tier
24 suites / 201 tests / 1138 assertions / 0 failures. e2e 394 scripts (from
410). Gates: e2e_reach, runner_reach 68 units, e2e_dup, accepted_divergences
60 pinned. Smoke green 12/0 in 38s.

Author: BuddhiLW

test/clj/suites/sort_test.clj

@@ -0,0 +1,54 @@
+;; sort / sort-by — comparator forms, stability, and NaN handling.
+;;
+;; Migrated from test/e2e/phase14_sort.sh; each assertion keeps its bash case
+;; name. `sort` returns a SEQ, so the cases that assert element order wrap in
+;; `into []` exactly as the script did, and the two that assert the return
+;; SHAPE keep their seq form.
+(ns suites.sort-test
+  (:require [clojure.test :refer [deftest is testing]]))
+
+(deftest sort-orders-by-natural-comparison
+  (is (= [1 2 3] (into [] (sort [3 1 2]))))                 ; sort_int
+  (is (= ["a" "b" "c"] (into [] (sort ["c" "a" "b"]))))     ; sort_str
+  (is (= [:a :b :c] (into [] (sort [:c :a :b]))))           ; sort_kw
+  (is (= [] (into [] (sort []))))                           ; sort_empty
+  (is (= [1 1 2 2] (into [] (sort [2 1 2 1])))))            ; sort_dup
+
+(deftest sort-takes-an-explicit-comparator
+  (is (= [3 2 1] (into [] (sort > [3 1 2]))))                       ; sort_gt
+  (is (= [1 2 3] (into [] (sort < [3 1 2]))))                       ; sort_lt
+  (testing "a numeric-difference comparator works too"
+    (is (= [3 2 1] (into [] (sort (fn [a b] (- b a)) [1 2 3])))))) ; sort_numcmp
+
+(deftest sort-by-projects-then-orders
+  (is (= ["b" "aa" "ccc"] (into [] (sort-by count ["aa" "b" "ccc"]))))       ; sort_by_len
+  (is (= ["ccc" "aa" "b"] (into [] (sort-by count > ["aa" "b" "ccc"]))))     ; sortby_gt
+  (testing "the sort is STABLE: an all-equal key preserves input order"
+    (is (= [3 1 2] (into [] (sort-by (fn* [x] 0) [3 1 2]))))))              ; sort_stable
+
+(deftest both-return-a-seq
+  (is (= '(1 2 3) (sort [3 1 2])))                          ; sort_seq
+  (is (true? (seq? (sort [3 1 2]))))                        ; sort_isseq
+  (is (= '(3 2 1) (sort-by - [3 1 2]))))                    ; sortby_seq
+
+;; NaN is unordered: every comparison against it is false, so it can neither
+;; sink nor rise. What must hold is that sorting does not LOSE or duplicate it.
+;;
+;; These assert the PRINTED form on purpose. NaN is not `=` to itself, so
+;; `(= [1 ##NaN] [1 ##NaN])` is FALSE and a value assertion here would fail
+;; whatever sort did — the bash compared printed text, which is what actually
+;; discriminates the placement.
+(deftest nan-neither-sorts-nor-disappears
+  (is (= "[1 ##NaN]" (pr-str (into [] (sort [1 ##NaN])))))                 ; sort_nan_int
+  (is (= "[2.0 ##NaN]" (pr-str (into [] (sort [2.0 ##NaN])))))             ; sort_nan_flt
+  (is (= "[1 ##NaN]" (pr-str (into [] (sort-by identity [1 ##NaN])))))     ; sortby_nan
+  (testing "and the element count survives"
+    (is (= 3 (count (sort [3 ##NaN 1]))))                          ; sort_nan_cnt
+    (is (= 4 (count (sort [2.0 ##NaN 1.0 3.0]))))))                ; sort_nan_fcnt
+
+;; a size the old O(n log n)-with-a-bad-constant path choked on; this is a
+;; regression guard, not a timing assertion
+(deftest it-scales
+  (is (= 5000 (count (sort (reverse (range 5000))))))       ; sort_large
+  (is (= 0 (first (sort (reverse (range 5000))))))          ; sort_large_min
+  (is (= 4999 (last (sort (reverse (range 5000)))))))       ; sort_large_max

test/e2e/phase14_sort.sh

@@ -817,7 +817,6 @@ run_step "e2e_phase14_dedup_group"           "bash test/e2e/phase14_dedup_group.
 run_step "e2e_phase14_reduce_helpers"        "bash test/e2e/phase14_reduce_helpers.sh"
 run_step "e2e_phase14_accessors"             "bash test/e2e/phase14_accessors.sh"
 run_step "e2e_phase14_compare"               "bash test/e2e/phase14_compare.sh"
-run_step "e2e_phase14_sort"                  "bash test/e2e/phase14_sort.sh"
 run_step "e2e_phase14_hierarchy"             "bash test/e2e/phase14_hierarchy.sh"
 run_step "e2e_phase14_deftype_object"        "bash test/e2e/phase14_deftype_object.sh"
 run_step "e2e_phase14_deftype_mutable"       "bash test/e2e/phase14_deftype_mutable.sh"