def test_map_cons():
meta = lmap.m(tag="async")
m1 = lmap.map({"first": "Chris"}, meta=meta)
m2 = m1.cons({"last": "Cronk"})
assert m1 is not m2
assert m1 != m2
assert len(m2) == 2
assert meta == m1.meta
assert meta == m2.meta
assert "Chris" == m1.get("first")
assert not m1.contains("last")
assert "Cronk" == m2.get("last")
assert "Chris" == m2.get("first")
meta = lmap.m(tag="async")
m1 = lmap.map({"first": "Chris"}, meta=meta)
m2 = m1.cons(MapEntry.of("last", "Cronk"))
assert m1 is not m2
assert m1 != m2
assert len(m2) == 2
assert meta == m1.meta
assert meta == m2.meta
assert "Chris" == m1.get("first")
assert not m1.contains("last")
assert "Cronk" == m2.get("last")
assert "Chris" == m2.get("first")
meta = lmap.m(tag="async")
m1 = lmap.map({"first": "Chris"}, meta=meta)
m2 = m1.cons(["last", "Cronk"])
assert m1 is not m2
assert m1 != m2
assert len(m2) == 2
assert meta == m1.meta
assert meta == m2.meta
assert "Chris" == m1.get("first")
assert not m1.contains("last")
assert "Cronk" == m2.get("last")
assert "Chris" == m2.get("first")
meta = lmap.m(tag="async")
m1 = lmap.map({"first": "Chris"}, meta=meta)
m2 = m1.cons(["last", "Cronk"], v("middle", "L"))
assert m1 is not m2
assert m1 != m2
assert len(m2) == 3
assert meta == m1.meta
assert meta == m2.meta
assert "Chris" == m1.get("first")
assert not m1.contains("middle")
assert not m1.contains("last")
assert "Cronk" == m2.get("last")
assert "L" == m2.get("middle")
assert "Chris" == m2.get("first")
with pytest.raises(ValueError):
m1 = lmap.map({"first": "Chris"})
m1.cons(["last"])
def test_reset_atom_meta():
a = atom.Atom(None)
assert a.meta is None
a.reset_meta(lmap.map({"type": sym.symbol("str")}))
assert a.meta == lmap.m(type=sym.symbol("str"))
a.reset_meta(lmap.m(tag=kw.keyword("async")))
assert a.meta == lmap.m(tag=kw.keyword("async"))
def test_alter_atom_meta():
a = atom.Atom(None)
assert a.meta is None
a.alter_meta(runtime.assoc, "type", sym.symbol("str"))
assert a.meta == lmap.m(type=sym.symbol("str"))
a.alter_meta(runtime.assoc, "tag", kw.keyword("async"))
assert a.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_reset_ns_meta(
ns_cache: atom.Atom[NamespaceMap],
ns_sym: sym.Symbol,
):
ns = get_or_create_ns(ns_sym)
assert ns.meta is None
ns.reset_meta(lmap.map({"type": sym.symbol("str")}))
assert ns.meta == lmap.m(type=sym.symbol("str"))
ns.reset_meta(lmap.m(tag=kw.keyword("async")))
assert ns.meta == lmap.m(tag=kw.keyword("async"))
def test_alter_ns_meta(
ns_cache: atom.Atom[NamespaceMap],
ns_sym: sym.Symbol,
):
ns = get_or_create_ns(ns_sym)
assert ns.meta is None
ns.alter_meta(runtime.assoc, "type", sym.symbol("str"))
assert ns.meta == lmap.m(type=sym.symbol("str"))
ns.alter_meta(runtime.assoc, "tag", kw.keyword("async"))
assert ns.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_alter_var_meta(
ns_sym: sym.Symbol,
var_name: sym.Symbol,
intern_val,
):
v = Var.intern(ns_sym, var_name, intern_val)
assert v.meta is None
v.alter_meta(assoc, "type", sym.symbol("str"))
assert v.meta == lmap.m(type=sym.symbol("str"))
v.alter_meta(assoc, "tag", kw.keyword("async"))
assert v.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_reset_var_meta(
ns_sym: sym.Symbol,
var_name: sym.Symbol,
intern_val,
):
v = Var.intern(ns_sym, var_name, intern_val)
assert v.meta is None
v.reset_meta(lmap.map({"type": sym.symbol("str")}))
assert v.meta == lmap.m(type=sym.symbol("str"))
v.reset_meta(lmap.m(tag=kw.keyword("async")))
assert v.meta == lmap.m(tag=kw.keyword("async"))
def test_hash_map_creator():
assert lmap.m() == lmap.hash_map()
assert lmap.map({1: 2}) == lmap.hash_map(1, 2)
assert lmap.map({1: 2, 3: 4}) == lmap.hash_map(1, 2, 3, 4)
with pytest.raises(IndexError):
lmap.hash_map(1, 2, 3)
def test_vector_cons():
meta = lmap.m(tag="async")
v1 = vec.v(keyword("kw1"), meta=meta)
v2 = v1.cons(keyword("kw2"))
assert v1 is not v2
assert v1 != v2
assert len(v2) == 2
assert meta == v1.meta
assert meta == v2.meta
def test_assoc():
m = lmap.m()
assert lmap.map({"k": 1}) == m.assoc("k", 1)
assert lmap.PersistentMap.empty() == m
assert lmap.map({"a": 1, "b": 2}) == m.assoc("a", 1, "b", 2)
m1 = lmap.map({"a": 3})
assert lmap.map({"a": 1, "b": 2}) == m1.assoc("a", 1, "b", 2)
assert lmap.map({"a": 3, "b": 2}) == m1.assoc("b", 2)
def test_set_conj():
meta = lmap.m(tag="async")
s1 = lset.s(keyword("kw1"), meta=meta)
s2 = s1.cons(keyword("kw2"))
assert s1 is not s2
assert s1 != s2
assert len(s2) == 2
assert meta == s1.meta
assert meta == s2.meta
def test_map_repr():
m = lmap.m()
assert repr(m) == "{}"
m = lmap.map({keyword("key"): "val"})
assert repr(m) == '{:key "val"}'
m = lmap.map({keyword("key1"): "val1", keyword("key2"): 3})
assert repr(m) in ['{:key2 3 :key1 "val1"}', '{:key1 "val1" :key2 3}']
def test_vector_with_meta():
vec0 = vec.v("vec")
assert vec0.meta is None
meta1 = lmap.m(type=symbol("str"))
vec1 = vec.v("vec", meta=meta1)
assert vec1.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
vec2 = vec1.with_meta(meta2)
assert vec1 is not vec2
assert vec1 == vec2
assert vec2.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
vec3 = vec2.with_meta(meta3)
assert vec2 is not vec3
assert vec2 == vec3
assert vec3.meta == lmap.m(tag=keyword("macro"))
def test_list_with_meta():
l1 = llist.l("vec")
assert l1.meta is None
meta1 = lmap.m(type=symbol("str"))
l2 = llist.l("vec", meta=meta1)
assert l2.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
l3 = l2.with_meta(meta2)
assert l2 is not l3
assert l2 == l3
assert l3.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
l4 = l3.with_meta(meta3)
assert l3 is not l4
assert l3 == l4
assert l4.meta == lmap.m(tag=keyword("macro"))
def test_queue_with_meta():
q1 = lqueue.q("vec")
assert q1.meta is None
meta1 = lmap.m(type=symbol("str"))
q2 = lqueue.q("vec", meta=meta1)
assert q2.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
q3 = q2.with_meta(meta2)
assert q2 is not q3
assert q2 == q3
assert q3.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
q4 = q3.with_meta(meta3)
assert q3 is not q4
assert q3 == q4
assert q4.meta == lmap.m(tag=keyword("macro"))
def test_symbol_with_meta():
sym = symbol("sym")
assert sym.meta is None
meta1 = lmap.m(type=symbol("str"))
sym1 = symbol("sym", meta=meta1)
assert sym1.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
sym2 = sym1.with_meta(meta2)
assert sym1 is not sym2
assert sym1 == sym2
assert sym2.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
sym3 = sym2.with_meta(meta3)
assert sym2 is not sym3
assert sym2 == sym3
assert sym3.meta == lmap.m(tag=keyword("macro"))
def test_set_with_meta():
s1 = lset.s("vec")
assert s1.meta is None
meta1 = lmap.m(type=symbol("str"))
s2 = lset.s("vec", meta=meta1)
assert s2.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
s3 = s2.with_meta(meta2)
assert s2 is not s3
assert s2 == s3
assert s3.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
s4 = s3.with_meta(meta3)
assert s3 is not s4
assert s3 == s4
assert s4.meta == lmap.m(tag=keyword("macro"))
def test_queue_cons():
meta = lmap.m(tag="async")
q1 = lqueue.q(keyword("kw1"), meta=meta)
q2 = q1.cons(keyword("kw2"))
assert q1 is not q2
assert q1 != q2
assert q2 == lqueue.q(keyword("kw1"), keyword("kw2"))
assert len(q2) == 2
assert meta == q1.meta
assert q2.meta is None
q3 = q2.cons(3, "four")
assert q3 == lqueue.q(keyword("kw1"), keyword("kw2"), 3, "four")
def test_list_cons():
meta = lmap.m(tag="async")
l1 = llist.l(keyword("kw1"), meta=meta)
l2 = l1.cons(keyword("kw2"))
assert l1 is not l2
assert l1 != l2
assert l2 == llist.l(keyword("kw2"), keyword("kw1"))
assert len(l2) == 2
assert meta == l1.meta
assert l2.meta is None
l3 = l2.cons(3, "four")
assert l3 == llist.l("four", 3, keyword("kw2"), keyword("kw1"))
def test_map_with_meta():
m1 = lmap.m(key1="vec")
assert m1.meta is None
meta1 = lmap.m(type=symbol("str"))
m2 = lmap.map({"key1": "vec"}, meta=meta1)
assert m2.meta == meta1
meta2 = lmap.m(tag=keyword("async"))
m3 = m2.with_meta(meta2)
assert m2 is not m3
assert m2 == m3
assert m3.meta == lmap.m(tag=keyword("async"))
meta3 = lmap.m(tag=keyword("macro"))
m4 = m3.with_meta(meta3)
assert m3 is not m4
assert m3 == m4
assert m4.meta == lmap.m(tag=keyword("macro"))
def test_map_as_function():
assert None is lmap.m()(1)
assert None is lmap.m()("abc")
assert None is lmap.map({1: True, "2": 2, 3: "string"})("abc")
assert "string" == lmap.map({1: True, "2": 2, 3: "string"})(3)
assert 2 == lmap.map({1: True, "2": 2, 3: "string"})("2")
def test_queue_meta():
assert lqueue.q("vec").meta is None
meta = lmap.m(type=symbol("str"))
assert lqueue.q("vec", meta=meta).meta == meta
m = lmap.map({keyword("key1"): "val1", keyword("key2"): 3})
assert repr(m) in ['{:key2 3 :key1 "val1"}', '{:key1 "val1" :key2 3}']
def test_hash_map_creator():
assert lmap.m() == lmap.hash_map()
assert lmap.map({1: 2}) == lmap.hash_map(1, 2)
assert lmap.map({1: 2, 3: 4}) == lmap.hash_map(1, 2, 3, 4)
with pytest.raises(IndexError):
lmap.hash_map(1, 2, 3)
@pytest.mark.parametrize(
"o",
[
lmap.m(),
lmap.map({"a": 2}),
lmap.map({
"a": 2,
None: "NOTHINGNESS"
}),
lmap.map({
"a": 2,
keyword("b"): lmap.map({keyword("c"): "string"})
}),
],
)
def test_map_pickleability(pickle_protocol: int, o: lmap.PersistentMap):
assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
def test_symbol_meta():
assert symbol("sym").meta is None
meta = lmap.m(type=symbol("str"))
assert symbol("sym", meta=meta).meta == meta
def test_map_meta():
assert lmap.m(tag="str").meta is None
meta = lmap.m(type=symbol("str"))
assert lmap.map({"type": "vec"}, meta=meta).meta == meta
def test_set_meta():
assert lset.s("vec").meta is None
meta = lmap.m(type=symbol("str"))
assert lset.s("vec", meta=meta).meta == meta
def test_map_interface_membership(interface):
assert isinstance(lmap.m(), interface)
assert issubclass(lmap.PersistentMap, interface)
def test_list_meta():
assert llist.l("vec").meta is None
meta = lmap.m(type=symbol("str"))
assert llist.l("vec", meta=meta).meta == meta
def test_vector_meta():
assert vec.v("vec").meta is None
meta = lmap.m(type=symbol("str"))
assert vec.v("vec", meta=meta).meta == meta
