e623968b45
clojure.data: ported from the ClojureScript impl (jolt-native equality-partition fn instead of host-type protocol dispatch). Verified against Clojure's own data-test (12/13 canonical; the 13th needs nil-valued-map support, jolt-c7h). Used mapv over the reference's (doall (map …)) — jolt's lazy multi-coll map + doall don't force as a reduce accumulator (jolt-dzh). clojure.zip: jolt's was a broken custom reimplementation; replaced with a port of real clojure.zip (metadata-based locs). Uses (nth loc …) instead of (loc …) because meta-bearing vectors aren't invocable as fns (jolt-vh5). core: with-meta now accepts nil metadata (Clojure allows (with-meta x nil)); it crashed calling keys on nil. This is what unblocked zip's make-node. New vendored battery (test/clojure-stdlib/, from clojurust's suite with fixtures corrected to match real Clojure): walk 34, zip 33, data 61 all clean; edn guarded at 43 (still a stub — jolt-b7y). Conformance 218/218 all modes; full suite green.
149 lines
5.6 KiB
Clojure
149 lines
5.6 KiB
Clojure
(ns clojure.data-test.diff
|
|
(:require [clojure.test :refer [deftest is testing]]
|
|
;; NOTE (jolt): sequential-diff expectations corrected to match real Clojure —
|
|
;; clojure.data pads only to the max differing index (e.g. (diff [1 2 3] [1 9 3])
|
|
;; -> a=[nil 2], not [nil 2 nil]). The upstream clojurust fixtures had this wrong.
|
|
[clojure.data :refer [diff]]))
|
|
|
|
;; ── Atoms ────────────────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-equal-atoms
|
|
(testing "equal atoms"
|
|
(is (= [nil nil :a] (diff :a :a)))
|
|
(is (= [nil nil 1] (diff 1 1)))
|
|
(is (= [nil nil "hello"] (diff "hello" "hello")))
|
|
(is (= [nil nil nil] (diff nil nil)))
|
|
(is (= [nil nil true] (diff true true)))))
|
|
|
|
(deftest test-diff-unequal-atoms
|
|
(testing "unequal atoms"
|
|
(is (= [:a :b nil] (diff :a :b)))
|
|
(is (= [1 2 nil] (diff 1 2)))
|
|
(is (= ["a" "b" nil] (diff "a" "b")))
|
|
(is (= [nil 1 nil] (diff nil 1)))
|
|
(is (= [true false nil] (diff true false)))))
|
|
|
|
;; ── Maps ─────────────────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-equal-maps
|
|
(testing "equal maps"
|
|
(is (= [nil nil {:a 1 :b 2}] (diff {:a 1 :b 2} {:a 1 :b 2})))
|
|
(is (= [nil nil {}] (diff {} {})))))
|
|
|
|
(deftest test-diff-maps-only-in-a
|
|
(testing "keys only in a"
|
|
(let [[a b both] (diff {:a 1 :b 2} {:a 1})]
|
|
(is (= {:b 2} a))
|
|
(is (nil? b))
|
|
(is (= {:a 1} both)))))
|
|
|
|
(deftest test-diff-maps-only-in-b
|
|
(testing "keys only in b"
|
|
(let [[a b both] (diff {:a 1} {:a 1 :b 2})]
|
|
(is (nil? a))
|
|
(is (= {:b 2} b))
|
|
(is (= {:a 1} both)))))
|
|
|
|
(deftest test-diff-maps-different-values
|
|
(testing "same keys, different values"
|
|
(let [[a b both] (diff {:a 1 :b 2} {:a 1 :b 9})]
|
|
(is (= {:b 2} a))
|
|
(is (= {:b 9} b))
|
|
(is (= {:a 1} both)))))
|
|
|
|
(deftest test-diff-maps-nested
|
|
(testing "nested maps"
|
|
(let [[a b both] (diff {:a {:x 1 :y 2}} {:a {:x 1 :z 3}})]
|
|
(is (= {:a {:y 2}} a))
|
|
(is (= {:a {:z 3}} b))
|
|
(is (= {:a {:x 1}} both)))))
|
|
|
|
(deftest test-diff-maps-disjoint
|
|
(testing "completely disjoint maps"
|
|
(let [[a b both] (diff {:a 1} {:b 2})]
|
|
(is (= {:a 1} a))
|
|
(is (= {:b 2} b))
|
|
(is (nil? both)))))
|
|
|
|
;; ── Sets ─────────────────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-equal-sets
|
|
(testing "equal sets"
|
|
(is (= [nil nil #{1 2 3}] (diff #{1 2 3} #{1 2 3})))
|
|
(is (= [nil nil #{}] (diff #{} #{})))))
|
|
|
|
(deftest test-diff-sets
|
|
(testing "overlapping sets"
|
|
(let [[a b both] (diff #{1 2 3} #{2 3 4})]
|
|
(is (= #{1} a))
|
|
(is (= #{4} b))
|
|
(is (= #{2 3} both)))))
|
|
|
|
(deftest test-diff-disjoint-sets
|
|
(testing "disjoint sets"
|
|
(let [[a b both] (diff #{1 2} #{3 4})]
|
|
(is (= #{1 2} a))
|
|
(is (= #{3 4} b))
|
|
(is (nil? both)))))
|
|
|
|
;; ── Vectors / Sequential ────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-equal-vectors
|
|
(testing "equal vectors"
|
|
(is (= [nil nil [1 2 3]] (diff [1 2 3] [1 2 3])))
|
|
(is (= [nil nil []] (diff [] [])))))
|
|
|
|
(deftest test-diff-vectors-same-length
|
|
(testing "same length, different elements"
|
|
(let [[a b both] (diff [1 2 3] [1 9 3])]
|
|
(is (= [nil 2] a))
|
|
(is (= [nil 9] b))
|
|
(is (= [1 nil 3] both)))))
|
|
|
|
(deftest test-diff-vectors-different-length
|
|
(testing "different lengths"
|
|
(let [[a b both] (diff [1 2 3] [1 2])]
|
|
(is (= [nil nil 3] a))
|
|
(is (nil? b))
|
|
(is (= [1 2] both)))
|
|
(let [[a b both] (diff [1] [1 2 3])]
|
|
(is (nil? a))
|
|
(is (= [nil 2 3] b))
|
|
(is (= [1] both)))))
|
|
|
|
(deftest test-diff-lists
|
|
(testing "lists treated as sequential"
|
|
(let [[a b both] (diff '(1 2 3) '(1 9 3))]
|
|
(is (= [nil 2] a))
|
|
(is (= [nil 9] b))
|
|
(is (= [1 nil 3] both)))))
|
|
|
|
;; ── Mixed types ─────────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-mixed-types
|
|
(testing "different partition types treated as atoms"
|
|
(is (= [{:a 1} [1 2] nil] (diff {:a 1} [1 2])))
|
|
(is (= [#{1} [1] nil] (diff #{1} [1])))
|
|
(is (= [1 :a nil] (diff 1 :a)))))
|
|
|
|
;; ── Nil handling ────────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-nil
|
|
(testing "nil vs non-nil"
|
|
(is (= [nil 1 nil] (diff nil 1)))
|
|
(is (= [1 nil nil] (diff 1 nil)))
|
|
(is (= [nil {:a 1} nil] (diff nil {:a 1})))))
|
|
|
|
;; ── Deeply nested ───────────────────────────────────────────────────────────
|
|
|
|
(deftest test-diff-deeply-nested
|
|
(testing "deeply nested structures"
|
|
(let [[a b both] (diff {:a {:b {:c 1}}} {:a {:b {:c 2}}})]
|
|
(is (= {:a {:b {:c 1}}} a))
|
|
(is (= {:a {:b {:c 2}}} b))
|
|
(is (nil? both))))
|
|
(testing "deeply nested with shared keys"
|
|
(let [[a b both] (diff {:a {:b 1 :c 2}} {:a {:b 1 :c 9}})]
|
|
(is (= {:a {:c 2}} a))
|
|
(is (= {:a {:c 9}} b))
|
|
(is (= {:a {:b 1}} both)))))
|