(use Array) (load "Test.carp") (use Test) (defn nested [] [[1 2 3] [4 5 6] [7 8 9]]) (defn excl [x] (String.append &x "!")) (defn excl-ref [x] (String.append x "!")) (defn inc-ref [x] (+ @x 1)) (defn make-zero [] 0) (defn make-idx [i] i) (def a (range 0 9 1)) (def b (Array.replicate 5 "Hi")) (deftest test (assert-true test (= &[1 2 3] &[1 2 3]) "= works as expected I") (assert-false test (= &[1 2 3] &[1 2 3 4]) "= works as expected II") (assert-false test (= &[1 2 3] &[1 2 34]) "= works as expected III") (assert-true test (/= &[1 2 3] &[1 2 3 4]) "/= works as expected I") (assert-true test (/= &[1 2 4] &[1 2 3]) "/= works as expected II") (assert-equal test &[0 0 0 0] &(replicate 4 &0) "replicate works as expected") (assert-equal test &[0 0 0 0] &(repeat 4 &make-zero) "repeat works as expected") (assert-equal test &[0 1 2 3] &(repeat-indexed 4 make-idx) "repeat-indexed works as expected") (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-equal test &(the (Maybe Int) (Maybe.Nothing)) &(first &[]) "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-equal test &(the (Maybe Char) (Maybe.Nothing)) &(last &[]) "last works as expected on empty array") (assert-equal test &[3 2 1] &(reverse [1 2 3]) "reverse works as expected") (assert-equal test &(Maybe.Just 10) &(maximum &(range 1 10 1)) "maximum works as expected") (assert-equal test &(Maybe.Just 1) &(minimum &(range 1 10 1)) "minimum 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 (Pair.init 1 3)) &(minimum &[(Pair.init 1 3) (Pair.init 2 1) (Pair.init 2 0)]) "minimum works on pairs") (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-equal test &(Maybe.Nothing) &(index-of &[1 2 3 4] &7) "index-of works as expected when element is not in the array") (assert-equal test 55 (sum &(range 1 10 1)) "sum works as expected") (assert-equal test &[2 3] &(slice &(range 1 10 1) 1 3) "slice works as expected") (assert-equal test &[1 2 3] &(prefix &(range 1 10 1) 3) "prefix works as expected") (assert-equal test &[8 9 10] &(suffix &(range 1 10 1) 7) "suffix works as expected") (assert-equal test &(Maybe.Nothing) &(nth &a 100) "nth works as expected") (assert-equal test &(Maybe.Just 0) &(nth &a 0) "nth works as expected") (assert-equal test 5 @(unsafe-nth &a 5) "unsafe-nth works as expected") (assert-equal test &[1 2 3] (unsafe-nth &(nested) 0) "unsafe-nth works as expected") (assert-equal test &[10 11 12 13 14 15] &(range 10 15 1) "range works as expected") (assert-equal test &[10.0 10.5 11.0 11.5 12.0] &(range 10.0 12.0 0.5) "range works as expected on non-integers") (assert-equal test &[10 9 8 7 6 5 4 3 2 1 0] &(range 10 0 -1) "range backwards works as expected") (assert-equal test &[1 3 5 7 9] &(range 1 10 2) "range works as expected if we dont exactly hit") (assert-equal test &[10 8 6 4 2] &(range 10 1 -2) "range backwards works as expected if we dont exactly hit") (assert-equal test &[@"Hi!" @"Hi!" @"Hi!" @"Hi!" @"Hi!"] &(copy-map &excl-ref &b) "copy-map works as expected") (assert-equal test &[@"Hi!" @"Hi!" @"Hi!" @"Hi!" @"Hi!"] &(endo-map &excl @&b) "endo-map works as expected") (assert-equal test &[1 2] &(swap [2 1] 0 1) "swap works as expected") (assert-equal test &[2 1] &(let-do [arr [1 2]] (Array.swap! &arr 0 1) arr) "swap! works as expected") (assert-equal test &[1 3] &(aupdate [1 2] 1 &inc-ref) "aupdate works as expected") (assert-equal test &[1 3] &(let-do [arr [1 2]] (aupdate! &arr 1 &inc-ref) arr) "aupdate! works as expected") (assert-equal test &[1 2 3 4 5 6 7 8] &(concat &[[1] [2 3] [4 5 6] [7 8]]) "concat works as expected") (assert-equal test &[11 22 33] &(zip &add-ref &[1 2 3 4 5 6 7] &[10 20 30]) "zip works as expected") (assert-equal test "[(Pair 0 @\"a\") (Pair 1 @\"b\") (Pair 2 @\"c\")]" &(str &(Array.enumerated &[@"a" @"b" @"c"])) "enumerated works as expected") (let-do [arr [1 2 3 4 5 6] exp [1 2 3 4 5 6 7] new (Array.push-back arr 7)] (assert-equal test &exp &new "Array.push-back works as expected")) (let-do [arr [1 2 3] exp [1 2 3 4 5 6 7 8 9 10 11 12 13 14]] (Array.push-back! &arr 4) (Array.push-back! &arr 5) (Array.push-back! &arr 6) (Array.push-back! &arr 7) (Array.push-back! &arr 8) (Array.push-back! &arr 9) (Array.push-back! &arr 10) (Array.push-back! &arr 11) (Array.push-back! &arr 12) (Array.push-back! &arr 13) (Array.push-back! &arr 14) (assert-equal test &exp &arr "Array.push-back! works as expected")) (let-do [a [1 2 3 4 5 6] b (Array.pop-back a) c (Array.pop-back b) d (Array.pop-back c) exp [1 2 3]] (assert-equal test &exp &d "Array.pop-back works as expected")) (let-do [arr [1 2 3 4 5 6] exp [1 2 3] six (Array.pop-back! &arr) five (Array.pop-back! &arr) four (Array.pop-back! &arr)] (assert-true test (and* (= &exp &arr) (= six 6) (= five 5) (= four 4)) "Array.pop-back! works as expected")) (assert-equal test &[1 2 3 4 5 6 7 8 9] &(sort (range 9 1 -1)) "sort works as expected") (let-do [arr [3 2 5] exp [2 3 5]] (sort! &arr) (assert-equal test &exp &arr "sort! works as expected")) (assert-equal test &[1 2 3 4 5 6 7 8 9] &(sorted &[9 2 1 3 7 8 6 5 4]) "sorted works as expected") (assert-equal test true (empty? &(the (Array ()) [])) "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)) &(range 0 10 1)) "any? works as expected I") (assert-equal test false (any? &(fn [x] (= 0 @x)) &(range 1 10 1)) "any? works as expected II") (assert-equal test true (all? &(fn [x] (< 0 @x)) &(range 1 10 1)) "all? works as expected I") (assert-equal test false (all? &(fn [x] (= 0 @x)) &(range 10 1 -1)) "all? works as expected II") (assert-equal test &(Maybe.Just 3) &(find &(fn [x] (= 3 @x)) &(range 1 10 1)) "find works as expected I") (assert-equal test &(Maybe.Nothing) &(find &(fn [x] (= 0 @x)) &(range 1 10 1)) "find works as expected II") (assert-equal test &(Maybe.Nothing) &(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 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") (assert-equal test &1 (Pointer.to-ref (unsafe-raw &[1 2 3])) "unsafe-raw works") (assert-equal test &2 (Pointer.to-ref (Pointer.inc (unsafe-raw &[1 2 3]))) "unsafe-raw works II") (assert-equal test &[1 3 5] &(remove &2 [2 1 3 2 5]) "remove works") (assert-equal test &[1 3] &(remove &2 [1 3]) "remove works when element is not found") (assert-equal test &[1 3] &(remove-nth 1 [1 2 3]) "remove-nth works") (assert-equal test &[1.0 1.5 2.0 2.5] &(unreduce 1.0 &(fn [x] (< x 3.0)) &(fn [x] (+ x 0.5))) "unreduce works") (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 2 3] &(from-static $[1 2 3]) "from-static works"))