| 1 |
(local t (require :test.faith)) |
| 2 |
(local fennel (require :fennel)) |
| 3 |
|
| 4 |
(macro == [form expected ?opts] |
| 5 |
`(let [(ok# val#) (pcall fennel.eval ,(view form) ,?opts)] |
| 6 |
(t.is ok# val#) |
| 7 |
(t.= val# ,expected))) |
| 8 |
|
| 9 |
(fn test-each [] |
| 10 |
(== (each [x (pairs [])] nil) nil) |
| 11 |
(== (let [t {:a 1 :b 2} t2 {}] |
| 12 |
(each [k v (pairs t)] |
| 13 |
(tset t2 k v)) |
| 14 |
(+ t2.a t2.b)) 3) |
| 15 |
(== (do (var t 0) (local (f s v) (pairs [1 2 3])) |
| 16 |
(each [_ x (values f (doto s (table.remove 1)))] (set t (+ t x))) t) 5) |
| 17 |
(== (do (var t 0) (local (f s v) (pairs [1 2 3])) |
| 18 |
(each [_ x (values f s v)] (set t (+ t x))) t) 6) |
| 19 |
(== (do (var x 0) (while (< x 7) (set x (+ x 1))) x) 7) |
| 20 |
(== (let [x [] y [1 2 3]] |
| 21 |
(each [(i n) (ipairs y)] |
| 22 |
(table.insert x (+ i n))) |
| 23 |
x) [2 4 6])) |
| 24 |
|
| 25 |
(fn test-for [] |
| 26 |
(== (for [y 0 2] nil) nil) |
| 27 |
(== (do (var x 0) (for [y 1 20 2] (set x (+ x 1))) x) 10) |
| 28 |
(== (do (var x 0) (for [y 1 5] (set x (+ x 1))) x) 5)) |
| 29 |
|
| 30 |
(fn test-comprehensions [] |
| 31 |
(== (collect [k v (pairs {:a 1 :b 2 :c 3})] v k) |
| 32 |
[:a :b :c]) |
| 33 |
(== (collect [k v (pairs {:apple :red :orange :orange})] |
| 34 |
(values (.. :color- v) (.. :fruit- k))) |
| 35 |
{:color-red :fruit-apple :color-orange :fruit-orange}) |
| 36 |
(== (collect [k v (pairs {:foo 3 :bar 4 :baz 5 :qux 6})] |
| 37 |
(if (> v 4) (values k (+ v 1)))) |
| 38 |
{:baz 6 :qux 7}) |
| 39 |
(== (collect [k v (pairs {:neon :lights}) &into {:shimmering-neon :lights}] |
| 40 |
(values k (v:upper))) |
| 41 |
{:neon "LIGHTS" :shimmering-neon "lights"}) |
| 42 |
(== (icollect [_ v (ipairs [1 2 3 4 5 6])] |
| 43 |
(if (= 0 (% v 2)) (* v v))) |
| 44 |
[4 16 36]) |
| 45 |
(== (icollect [num (string.gmatch "24,58,1999" "%d+")] |
| 46 |
(tonumber num)) |
| 47 |
[24 58 1999]) |
| 48 |
(== (icollect [_ x (ipairs [2 3]) &into [11]] (* x 11)) |
| 49 |
[11 22 33]) |
| 50 |
(== (let [xs [11]] (icollect [_ x (ipairs [2 3]) &into xs] (* x 11))) |
| 51 |
[11 22 33]) |
| 52 |
(let [code "(icollect [_ x (ipairs [2 3]) &into \"oops\"] x)" |
| 53 |
(ok? msg) (pcall fennel.compileString code)] |
| 54 |
(t.is (not ok?)) |
| 55 |
(t.match "&into clause" msg)) |
| 56 |
(let [code "(icollect [_ x (ipairs [2 3]) &into 2] x)" |
| 57 |
(ok? msg) (pcall fennel.compileString code)] |
| 58 |
(t.is (not ok?)) |
| 59 |
(t.match "&into clause" msg)) |
| 60 |
(== (do (macro twice [expr] `(do ,expr ,expr)) |
| 61 |
(twice (icollect [i v (ipairs [:a :b :c])] v))) |
| 62 |
[:a :b :c]) |
| 63 |
(== (let [result [0]] |
| 64 |
(icollect [_ v (ipairs [1 2 [3 4 5] 6 7]) &into result] |
| 65 |
(case (type v) |
| 66 |
:table (do |
| 67 |
(icollect [_ e (ipairs v) &into result] e) |
| 68 |
nil) |
| 69 |
_ v))) |
| 70 |
[0 1 2 3 4 5 6 7]) |
| 71 |
(== (fcollect [i 1 4] i) |
| 72 |
[1 2 3 4]) |
| 73 |
(== (fcollect [i 1 4 2] i) |
| 74 |
[1 3]) |
| 75 |
(== (fcollect [i 1 10 2 &until (> i 5)] i) |
| 76 |
[1 3 5]) |
| 77 |
(== (fcollect [i 1 10 2 :until (> i 5)] i) |
| 78 |
[1 3 5]) |
| 79 |
(== (fcollect [i 1 4 &into [0]] i) |
| 80 |
[0 1 2 3 4]) |
| 81 |
(== (fcollect [i 1 4 :into [0]] i) |
| 82 |
[0 1 2 3 4]) |
| 83 |
(== (fcollect [i 1 4 2 &into [0]] i) |
| 84 |
[0 1 3]) |
| 85 |
(== (fcollect [i 1 10 2 |
| 86 |
&into [0] |
| 87 |
&until (> i 5)] |
| 88 |
(when (not= i 3) i)) |
| 89 |
[0 1 5])) |
| 90 |
|
| 91 |
(fn test-accumulate [] |
| 92 |
(== (do (var x true) |
| 93 |
(let [y (accumulate [state :init |
| 94 |
_ _ (pairs {})] |
| 95 |
(do (set x false) |
| 96 |
:update))] |
| 97 |
[x y])) |
| 98 |
[true :init]) |
| 99 |
(== (accumulate [s :fen |
| 100 |
_ c (ipairs [:n :e :l :o]) &until (>= c :o)] |
| 101 |
(.. s c)) |
| 102 |
"fennel") |
| 103 |
(== (accumulate [n 0 _ _ (pairs {:one 1 :two nil :three 3})] |
| 104 |
(+ n 1)) |
| 105 |
2) |
| 106 |
(== (accumulate [yes? true |
| 107 |
_ s (ipairs [:yes :no :yes])] |
| 108 |
(and yes? (string.match s :yes))) |
| 109 |
nil) |
| 110 |
(== (let [(a b) (accumulate [(x y) (values 8 2) _ (ipairs [1])] (values y x))] |
| 111 |
(+ a b)) 10) |
| 112 |
(== (do (macro twice [expr] `(do ,expr ,expr)) |
| 113 |
(twice (accumulate [s "" _ v (ipairs [:a :b])] (.. s v)))) |
| 114 |
:ab)) |
| 115 |
|
| 116 |
(fn test-faccumulate [] |
| 117 |
(== 15 (faccumulate [sum 0 i 1 5] (+ sum i))) |
| 118 |
(== 6 (faccumulate [sum 0 i 1 5 &until (= i 4)] (+ sum i))) |
| 119 |
(== "EDCBA" (faccumulate [alphabet "" i 4 0 -1] |
| 120 |
(.. alphabet (string.char (+ i 65)))))) |
| 121 |
|
| 122 |
(fn test-conditions [] |
| 123 |
(== (do (var x 0) (for [i 1 10 &until (= i 5)] (set x i)) x) 4) |
| 124 |
(== (do (var x 0) (each [_ i (ipairs [1 2 3]) &until (< 2 x)] (set x i)) x) 3) |
| 125 |
(== (icollect [_ i (ipairs [4 5 6]) &until (= i 5)] i) [4]) |
| 126 |
(== (collect [i x (pairs [4 5 6]) &until (= x 6)] (values i x)) [4 5]) |
| 127 |
(== (icollect [i x (pairs [4 5 6]) &into [3] &until (= x 6)] x) [3 4 5])) |
| 128 |
|
| 129 |
{: test-each |
| 130 |
: test-for |
| 131 |
: test-comprehensions |
| 132 |
: test-accumulate |
| 133 |
: test-faccumulate |
| 134 |
: test-conditions} |