(namespace tests.vec
  (test.case "vec.empty?" 
    (assert.ok! (vec.empty? []))
    (assert.not! (vec.empty? [1]))
  )

  (test.case "vec.len"
    (assert.eq! (vec.len []) 0)
    (assert.eq! (vec.len [1]) 1)
    (assert.eq! (vec.len [1 2 3]) 3)
  )

  (test.case "vec.first"
    (assert.eq! (vec.first [1 2 3]) 1)
    (assert.eq! (vec.first ["a"]) "a")
  )

  (test.case "vec.last"
    (assert.eq! (vec.last [1 2 3]) 3)
    (assert.eq! (vec.last ["x"]) "x")
  )

  (test.case "vec.get"
    (assert.eq! (vec.get [10 20 30] 0) 10)
    (assert.eq! (vec.get [10 20 30] 1) 20)
    (assert.eq! (vec.get [10 20 30] 2) 30)
  )

  (test.case "vec.map"
    (assert.eq! 
      (vec.map (lambda [x _] (+ x 1)) [1 2 3])
      [2 3 4])
  )

  (test.case "vec.filter"
    (assert.eq!
      (vec.filter (lambda [x _] (gt? x 1)) [1 2 3])
      [2 3])
  )

  (test.case "vec.has"
    (assert.ok! (vec.has [1 2 3] 2))
    (assert.not! (vec.has [1 2 3] 5))
  )

  (test.case "vec.includes?"
    (assert.ok! (vec.includes? [1 2 3] 2))
    (assert.not! (vec.includes? [1 2 3] 5))
  )

  (test.case "vec.find"
    (assert.eq! 
      (vec.find (lambda [x _] (gt? x 2)) [1 2 3 4])
      3)
  )

  (test.case "vec.reverse"
    (assert.eq! (vec.reverse [1 2 3]) [3 2 1])
  )

  (test.case "vec.take"
    (assert.eq! (vec.take [1 2 3 4 5] 3) [1 2 3])
  )

  (test.case "vec.drop"
    (assert.eq! (vec.drop [1 2 3 4 5] 2) [3 4 5])
  )

  (test.case "vec.uniq"
    (assert.eq! (vec.uniq [1 2 2 3 3 3]) [1 2 3])
  )

  (test.case "vec.every?"
    (assert.ok! (vec.every? (lambda [x _] (gt? x 0)) [1 2 3]))
    (assert.not! (vec.every? (lambda [x _] (gt? x 1)) [1 2 3]))
  )

  (test.case "vec.some?"
    (assert.ok! (vec.some? (lambda [x _] (gt? x 2)) [1 2 3]))
    (assert.not! (vec.some? (lambda [x _] (gt? x 5)) [1 2 3]))
  )

  (test.case "vec.count"
    (assert.eq! (vec.count (lambda [x _] (gt? x 1)) [1 2 3]) 2)
  )

  (test.case "vec.sum"
    (assert.eq! (vec.sum [1 2 3]) 6)
    (assert.eq! (vec.sum []) 0)
  )
)