3 files changed, 91 insertions, 15 deletions
diff --git a/core_test.fnl b/core_test.fnl
index eb58a44..a7e981a 100644
--- a/core_test.fnl
+++ b/core_test.fnl
@@ -1,4 +1,5 @@
 (import-macros {: fn*} :macros.fn)
+(import-macros {: assert-eq : assert-ne : assert*} :test)
 
 (local {: seq
         : mapv
@@ -15,19 +16,25 @@
         : comp
         : every?} (require :core))
 
-;; Test equality function should be done first and with a lot of care,
-;; because we rely on deep comparison in other tests.
+;; comparing basetypes
+(assert-eq 1 1)
+(assert-ne 1 2)
+(assert* (eq? 1 1 1 1 1))
+(assert-eq 1.0 1.0)
+(assert* (eq? 1.0 1.0 1.0))
+(assert* (eq? 1.0 1.0 1.0))
+(assert* (eq? "1" "1" "1" "1" "1"))
 
-(assert (eq? 1 1))
-(assert (not (eq? 1 2)))
-(assert (eq? 1 1 1 1 1))
-(assert (eq? "1" "1" "1" "1" "1"))
-(assert (eq? [1 2] [1 2]))
-(assert (not (eq? [1] [1 2])))
-(assert (not (eq? [1 2] [1])))
-(assert (eq? [1 [2]] [1 [2]] [1 [2]]))
-(assert (eq? [1 [2]] [1 [2]] [1 [2]]))
-(assert (not (eq? [1 [2]] [1 [2]] [1 [2 [3]]])))
+;; deep comparison
+(assert* (eq? []))
+(assert-eq [] [])
+(assert-eq [] {})
+(assert-eq [1 2] [1 2])
+(assert-ne [1] [1 2])
+(assert-ne [1 2] [1])
+(assert* (eq? [1 [2]] [1 [2]] [1 [2]]))
+(assert* (eq? [1 [2]] [1 [2]] [1 [2]]))
+(assert* (not (eq? [1 [2]] [1 [2]] [1 [2 [3]]])))
 
 (fn* range
   ([upper] (range 0 upper 1))
@@ -38,6 +45,7 @@
        (table.insert res i))
      res)))
 
-(assert (eq? (range 10) [0 1 2 3 4 5 6 7 8 9]))
-(assert (eq? (range -5 5) [-5 -4 -3 -2 -1 0 1 2 3 4]))
-;; (assert (eq? (range 0 1 0.2) [0 0.2 0.4 0.6 0.8])) ;; TODO: fails, unsure why.
+(assert-eq (range 10) [0 1 2 3 4 5 6 7 8 9])
+(assert-eq (range -5 5) [-5 -4 -3 -2 -1 0 1 2 3 4])
+(assert-eq [0 0.2 0.4 0.6 0.8] [0 0.2 0.4 0.6 0.8])
+(assert-eq (range 0 1 0.2) (range 0 1 0.2))
diff --git a/macros_test.fnl b/macros_test.fnl
new file mode 100644
index 0000000..422f282
--- /dev/null
+++ b/macros_test.fnl
@@ -0,0 +1,44 @@
+(import-macros {: if-let : when-let : if-some : when-some : into} :macros.core)
+(import-macros {: assert-eq : assert-ne : assert*} :test)
+(local {: eq?} (require :core))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;; into ;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(assert-eq (into [] []) [])
+(assert-eq (into [1 2 3] []) [1 2 3])
+(assert-eq (into [1 2 3] [4 5 6]) [1 2 3 4 5 6])
+
+(assert-eq (into {} {}) {})
+(assert-eq (into {:a 1} {}) {:a 1})
+(assert-eq (into {:a 1} {:b 2}) {:a 1 :b 2})
+
+(assert-eq (into [] {}) []) ;; different bodies are being used so worth testing
+(assert-eq (into {} []) [])
+
+;; can't transform table with more than one key-value pair, as order
+;; is undeterminitive
+(assert-eq (into [] {:a 1}) [[:a 1]])
+(assert-eq (into [[:b 2]] {:a 1}) [[:b 2] [:a 1]])
+(assert-eq (into [[:c 3]] {}) [[:c 3]])
+
+(assert-eq (into {} [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3})
+(assert-eq (into {:d 4} [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3 :d 4})
+(assert-eq (into {:a 0 :b 0 :c 0} [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3})
+
+;;;;;;;;;;;;;;;;;;;;;;; let variants ;;;;;;;;;;;;;;;;;;;;;;;;
+
+(assert-eq (when-let [a 4] a) 4)
+(assert* (not (when-let [a false] a)) "(not (when-let [a false] a))")
+(assert* (not (when-let [a nil] a)) "(not (when-let [a nil] a))")
+
+(assert-eq (when-some [a [1 2 3]] a) [1 2 3])
+(assert-eq (when-some [a false] a) false)
+(assert* (not (when-some [a nil] a)) "(when-some [a nil] a)")
+
+(assert-eq (if-let [a 4] a 10) 4)
+(assert-eq (if-let [a false] a 10) 10)
+(assert-eq (if-let [a nil] a 10) 10)
+
+(assert-eq (if-some [a [1 2 3]] a :nothing) [1 2 3])
+(assert-eq (if-some [a false] a :nothing) false)
+(assert-eq (if-some [a nil] a :nothing) :nothing)
diff --git a/test.fnl b/test.fnl
new file mode 100644
index 0000000..cb26858
--- /dev/null
+++ b/test.fnl
@@ -0,0 +1,24 @@
+;; requires `eq?' from core.fnl to be available at runtime
+
+(fn assert-eq [expr1 expr2 msg]
+  `(let [left# ,expr1
+         right# ,expr2
+         view# (require :fennelview)]
+     (assert (eq? left# right#) (or ,msg (.. "equality assertion failed
+  Left: " (view# ,expr1) "
+  Right: " (view# ,expr2) "\n")))))
+
+(fn assert-ne [expr1 expr2 msg]
+  `(let [left# ,expr1
+         right# ,expr2
+         view# (require :fennelview)]
+     (assert (not (eq? left# right#)) (or ,msg (.. "unequality assertion failed
+  Left: " (view# ,expr1) "
+  Right: " (view# ,expr2) "\n")))))
+
+(fn assert* [expr msg]
+  `(assert ,expr (.. "assertion failed for " ,(or msg (tostring expr)))))
+
+{: assert-eq
+ : assert-ne
+ : assert*}