d3194aae59
adds self-hosted compiler is functionally: - The default compile path is the portable pipeline using jolt.analyzer (Clojure) → host-neutral IR → backend.janet. - The analyzer is itself Clojure, compiled by jolt for true self-hosting. - bootstrap-fixpoint passes (stage1 == stage2 == stage3): rebuilding the compiler on its own output. - clojure.core is now self-hosted in the overlay. - Stateful forms (defmacro/ns/deftype/defmulti/require/in-ns) are interpreted by design.
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)))))
|