(namespace tests.map
  (test.case "map.len"
    (assert.eq! (map.len (map.new)) 0)
  )

  (test.case "map.empty?"
    (assert.ok! (map.empty? (map.new)))
  )

  (test.case "map.is-empty?"
    (assert.ok! (map.is-empty? (map.new)))
  )

  (test.case "map.get"
    (seq
      (def m (map.new :a 1 :b 2))
      (assert.eq! (map.get m :a) 1)
      (assert.eq! (map.get m :b) 2)
      (assert.eq! (map.get m :c) null)
    )
  )

  (test.case "map.put"
    (seq
      (def m (map.new :a 1))
      (def m2 (map.put m :b 2))
      (assert.eq! (map.len m2) 2)
      (assert.eq! (map.get m2 :b) 2)
    )
  )

  (test.case "map.has-key?"
    (seq
      (def m (map.new :a 1 :b 2))
      (assert.ok! (map.has-key? m :a))
      (assert.not! (map.has-key? m :c))
    )
  )

  (test.case "map.has-value?"
    (seq
      (def m (map.new :a 1 :b 2))
      (assert.ok! (map.has-value? m 1))
      (assert.not! (map.has-value? m 5))
    )
  )

  (test.case "map.keys"
    (seq
      (def m (map.new :a 1 :b 2))
      (def ks (map.keys m))
      (assert.eq! (vec.len ks) 2)
    )
  )

  (test.case "map.values"
    (seq
      (def m (map.new :a 1 :b 2))
      (def vs (map.values m))
      (assert.eq! (vec.len vs) 2)
    )
  )

  (test.case "map.merge"
    (seq
      (def m1 (map.new :a 1 :b 2))
      (def m2 (map.new :b 20 :c 3))
      (def m3 (map.merge m1 m2))
      (assert.eq! (map.get m3 :a) 1)
      (assert.eq! (map.get m3 :b) 20)
      (assert.eq! (map.get m3 :c) 3)
    )
  )

  (test.case "map.dissoc"
    (seq
      (def m (map.new :a 1 :b 2 :c 3))
      (def m2 (map.dissoc m :b))
      (assert.eq! (map.len m2) 2)
      (assert.not! (map.has-key? m2 :b))
    )
  )
)