mirror of
https://github.com/carp-lang/Carp.git
synced 2024-09-11 05:25:28 +03:00
230 lines
6.3 KiB
Plaintext
230 lines
6.3 KiB
Plaintext
(load "Test.carp")
|
|
(use Test)
|
|
(use StaticArray)
|
|
|
|
(deftest test
|
|
|
|
(let [arr $[1 2 4]]
|
|
(assert-equal test
|
|
$[2 4 8]
|
|
(do
|
|
(map! arr &(fn [val] (* @val 2)))
|
|
arr)
|
|
"map! works as expected"))
|
|
|
|
(let [arr $[1 2 3]]
|
|
(assert-equal test
|
|
$[3 2 1]
|
|
(do
|
|
(reverse! arr)
|
|
arr)
|
|
"reverse! works as expected"))
|
|
|
|
(assert-true test
|
|
(= $[1 2 3] $[1 2 3])
|
|
"= works as expected I")
|
|
|
|
(assert-false test
|
|
(= $[1 2 3] $[1 2 3 4 5])
|
|
"= works as expected II")
|
|
|
|
(assert-false test
|
|
(= $[1 1 1] $[0 0 0])
|
|
"= works as expected III")
|
|
|
|
(assert-equal test
|
|
5
|
|
(let [a $[0 1 2 3 4 5 6 7 8 9]]
|
|
@(unsafe-nth a 5))
|
|
"unsafe-nth works as expected")
|
|
|
|
(assert-equal test
|
|
&[4 5 6]
|
|
&(let [nested $[[1 2 3]
|
|
[4 5 6]
|
|
[7 8 9]]]
|
|
@(unsafe-nth nested 1))
|
|
"unsafe-nth works as expected with heap allocated elements")
|
|
|
|
(assert-equal test
|
|
10
|
|
(let [arr $[2 2 2 2]]
|
|
(reduce
|
|
&(fn [acc val] (+ acc @val))
|
|
2
|
|
arr))
|
|
"reduce works as expected")
|
|
|
|
(assert-equal test
|
|
true
|
|
(empty? (the (Ref (StaticArray Int)) $[]))
|
|
"empty? works as expected I")
|
|
|
|
(assert-equal test
|
|
false
|
|
(empty? $[1])
|
|
"empty? works as expected II")
|
|
|
|
(assert-equal test
|
|
true
|
|
(any? &(fn [x] (= 0 @x)) $[0 1 2 3])
|
|
"any? works as expected I")
|
|
|
|
(assert-equal test
|
|
false
|
|
(any? &(fn [x] (= 0 @x)) $[1 2 3 4])
|
|
"any? works as expected II")
|
|
|
|
(assert-equal test
|
|
true
|
|
(all? &(fn [x] (< 0 @x)) $[1 2 3])
|
|
"all? works as expected I")
|
|
|
|
(assert-equal test
|
|
false
|
|
(all? &(fn [x] (< 0 @x)) $[0 1 2])
|
|
"all? works as expected II")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 3)
|
|
&(find &(fn [x] (= 3 @x)) $[0 1 2 3])
|
|
"find works as expected I")
|
|
|
|
(assert-nothing test
|
|
&(find &(fn [x] (= 4 @x)) $[0 1 2 3])
|
|
"find works as expected II")
|
|
|
|
(assert-nothing test
|
|
&(find-index &(fn [i] (Int.even? @i)) $[1 3 5])
|
|
"find-index works I")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 1)
|
|
&(find-index &(fn [i] (Int.even? @i)) $[1 8 5])
|
|
"find-index works II")
|
|
|
|
(assert-equal test
|
|
1
|
|
(unsafe-first $[1 2 3])
|
|
"unsafe-first works as expected")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 1)
|
|
&(first $[1 2 3])
|
|
"first works as expected")
|
|
|
|
(assert-nothing test
|
|
&(first (the (Ref (StaticArray Int)) $[]))
|
|
"first works as expected on empty array")
|
|
|
|
(assert-equal test
|
|
\c
|
|
(unsafe-last $[\a \b \c])
|
|
"unsafe-last works as expected")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just \c)
|
|
&(last $[\a \b \c])
|
|
"last works as expected")
|
|
|
|
(assert-nothing test
|
|
&(last (the (Ref (StaticArray Char)) $[]))
|
|
"last works as expected on empty array")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 10)
|
|
&(maximum $[8 10 9])
|
|
"maximum works as expected")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just (Pair.init 2 1))
|
|
&(maximum $[(Pair.init 1 3) (Pair.init 2 1) (Pair.init 2 0)])
|
|
"maximum works on pairs")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 1)
|
|
&(minimum $[3 1 2])
|
|
"minimum works as expected")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just (Pair.init 1 3))
|
|
&(minimum $[(Pair.init 1 3) (Pair.init 2 1) (Pair.init 2 0)])
|
|
"minimum works on pairs")
|
|
|
|
(assert-equal test
|
|
55
|
|
(sum $[1 2 3 4 5 6 7 8 9 10])
|
|
"sum works as expected")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 3)
|
|
&(index-of $[1 2 3 4] &4)
|
|
"index-of works as expected when element is in the array")
|
|
|
|
(assert-nothing test
|
|
&(index-of $[1 2 3 4] &7)
|
|
"index-of works as expected when element is not in the array")
|
|
|
|
(assert-equal test
|
|
2
|
|
(element-count $[1 4 3 4] &4)
|
|
"element-count works as expected")
|
|
|
|
(assert-equal test
|
|
2
|
|
(predicate-count $[1 8 5 10 3] &(fn [i] (Int.even? @i)))
|
|
"predicate-count works")
|
|
|
|
(let [arr $[1 2]]
|
|
(assert-equal test
|
|
$[1 3]
|
|
(do
|
|
(aupdate! arr 1 &inc)
|
|
arr)
|
|
"aupdate! works as expected"))
|
|
|
|
(let [arr $[1 2]]
|
|
(assert-equal test
|
|
$[2 1]
|
|
(do
|
|
(StaticArray.swap! arr 0 1)
|
|
arr)
|
|
"swap! works as expected"))
|
|
|
|
(assert-nothing test
|
|
&(nth $[0 1 2] 3)
|
|
"nth works as expected I")
|
|
|
|
(assert-equal test
|
|
&(Maybe.Just 0)
|
|
&(nth $[0 1 2] 0)
|
|
"nth works as expected II")
|
|
|
|
(assert-true test
|
|
(contains? $[0 1 2] &1)
|
|
"contains? works as expected I")
|
|
|
|
(assert-false test
|
|
(contains? $[0 1 2] &100)
|
|
"contains? works as expected II")
|
|
|
|
(assert-equal test
|
|
&1
|
|
(Pointer.to-ref (unsafe-raw $[1 2 3]))
|
|
"unsafe-raw works as expected")
|
|
|
|
(assert-equal test
|
|
&2
|
|
(Pointer.to-ref (Pointer.inc (unsafe-raw $[1 2 3])))
|
|
"unsafe-raw works as expected II")
|
|
|
|
(let [arr $[1 1 1 1 1]]
|
|
(assert-equal test
|
|
$[1 2 3 4 5]
|
|
(do
|
|
(StaticArray.scan! &Int.+ arr)
|
|
arr)
|
|
"scan! works"))
|
|
|
|
)
|