045check.test

(test "if handles 0 args"
  :valueof (if)
  :should be_false)

(test "if handles 1 arg"
  :valueof if.3
  :should be 3)

(test "if handles 2 args"
  :valueof (if 3 4)
  :should be 4)

(test "if handles then branch"
  :valueof (if 3 4 5)
  :should be 4)

(test "if handles else branch"
  :valueof (if nil 4 5)
  :should be 5)

(test "if handles 4 args"
  :valueof (if nil 4 5 6)
  :should be 6)

(test "if handles 5 args"
  :valueof (if nil 4 nil 6 7)
  :should be 7)

(test "if handles :else"
  :valueof (if nil 4 :else 6)
  :should be 6)

(test "if handles lexical scope"
  :valueof (let x 34 (if x))
  :should be 34)

(test "if handles dynamic scope"
  :valueof (do (x <- 34)
               (if x 35))
  :should be 35)



(test "or handles 0 args"
  :valueof (or)
  :should be_false)

(test "or handles nil arg"
  :valueof or.nil
  :should be_false)

(test "or handles non-nil arg"
  :valueof or.3
  :should be 3)

(test "or handles 2 args"
  :valueof (or nil 3)
  :should be 3)

(test "or handles multiple non-nil args"
  :valueof (or 3 4)
  :should be 3)

(test "or short-circuits on first non-nil arg"
  :valueof (let x nil
             (or 3 (x <- 4))
             x)
  :should be_false)

(test "or evals each arg at most once"
  :valueof (let x 0
             (or (do (x <- x+1)
                     3)
                 (do (x <- x+1)
                     4))
             x)
  :should be 1)

(test "or handles lexical scope"
  :valueof (do (x <- 35)
               (let x 3
                 (or nil x)))
  :should be 3)

(test "or works with splice"
  :valueof (or @'(nil 1))
  :should be 1)

(test "or always returns false on failure"
  :valueof (or false nil)
  :should be false)  # might be worth fixing



(test "and handles 0 args"
  :valueof (and)
  :should be_true)

(test "and handles nil arg"
  :valueof and.nil
  :should be_false)

(test "and handles non-nil arg"
  :valueof and.3
  :should be 3)

(test "and handles 2 args"
  :valueof (and nil 3)
  :should be_false)

(test "and handles 2 non-nil args"
  :valueof (and 3 4)
  :should be 4)

(test "and handles lexical scope"
  :valueof ((fn(x) (and 3 x 4)) nil)
  :should be_false)

(test "and short-circuits"
  :valueof (let x 0
             (and (x <- 3)
                  nil
                  (x <- 4))
             x)
  :should be 3)

(test "and handles dynamic scope"
  :valueof (do (x <- 35)
               (and x 36))
  :should be 36)

(test "and works with splice"
  :valueof (and @'(1 2))
  :should be 2)



(test "equality handles nils"
  :valueof (nil = 3)
  :should be_false)

(test "equality compares nils"
  :valueof (nil = nil)
  :should be_true)

(test "equality handles ints"
  :valueof (3 = 4)
  :should be_false)

(test "equality handles ints - 2"
  :valueof (3 = 3)
  :should be_true)

(test "equality handles strings"
  :valueof ("a" = "b")
  :should be_false)

(test "equality handles strings - 2"
  :valueof ("a" = "a")
  :should be_true)

(test "equality handles lists"
  :valueof (list.1 = list.2)
  :should be_false)

(test "equality handles lists - 2"
  :valueof (list.1 = list.1)
  :should be_true)

(test "equality handles user-defined types"
  :valueof ('(type foo 3) = '(type foo 3))
  :should be_true)

(test "equality handles keyword syms"
  :valueof (let x :a  # also a keyword arg for '=
             (x = x))
  :should be_true)



(test "default works"
  :valueof (ret x nil
             (default x 3))
  :should be 3)

(test "default shortcuts unnecessary evals"
  :valueof (with (x 3 y nil)
             (default x :to (y <- 235))
             (list x y))
  :should be '(3 nil))

(test "default returns assigned value"
  :valueof (let x nil
             (default x :to 4))
  :should be 4)

(test "default returns old value on failure"
  :valueof (let x 3
             (default x :to 4))
  :should be 3)



(test "match? - atom positive"
  :valueof (match? 3 3)
  :should be_true)

(test "match? - atom negative"
  :valueof (match? 3 4)
  :should be_false)

(test "match? - list positive"
  :valueof (match? '(1 (2 3)) '(1 (2 3)))
  :should be_true)

(test "match? - list negative"
  :valueof (match? '(2 (2 3)) '(1 (2 3)))
  :should be_false)

(test "match? treats _ as atom wildcard"
  :valueof (match? '_ 3)
  :should be_true)

(test "match? - _ positive"
  :valueof (match? '(1 (_ 3 4)) '(1 (2 3 4)))
  :should be_true)

(test "match? - _ negative"
  :valueof (match? '(2 (_ 3 4)) '(1 (2 3 4)))
  :should be_false)

(test "match? - _ matches lists"
  :valueof (match? '_ '(3))
  :should be_true)

(test "match? - _ matches lists when dotted"
  :valueof (match? '(1 ... _) '(1 2 3))
  :should be_true)

(test "match? - _ matches nil when dotted"
  :valueof (match? '(1 ... _) '(1))
  :should be_true)



(test "caselet works"
  :valueof (caselet x 'b
             'a
               1
             'b
               2
               3)
  :should be 2)

(test "case works"
  :valueof (with (x 1 y 2 z 3 w 2)
             (case w
               x
                 34
               y
                 35
               z
                 36))
  :should be 35)

(test "case uses predicate"
  :valueof (let x '(3)
             (case x
               cons?
                 34
               (fn(_) 1)
                 36))
  :should be 34)

(test "case recognizes keyword :else"
  :valueof (let x '(3)
             (case x
               ~cons?
                 34
               :else
                 35))
  :should be 35)