def test_to_seq():
assert None is runtime.to_seq(None)
assert None is runtime.to_seq(llist.PersistentList.empty())
assert None is runtime.to_seq(vec.PersistentVector.empty())
assert None is runtime.to_seq(lmap.PersistentMap.empty())
assert None is runtime.to_seq(lset.PersistentSet.empty())
assert None is runtime.to_seq("")
assert None is not runtime.to_seq(llist.l(None))
assert None is not runtime.to_seq(llist.l(None, None, None))
assert None is not runtime.to_seq(llist.l(1))
assert None is not runtime.to_seq(vec.v(1))
assert None is not runtime.to_seq(lmap.map({"a": 1}))
assert None is not runtime.to_seq(lset.s(1))
assert None is not runtime.to_seq("string")
one_elem = llist.l(kw.keyword("kw"))
assert one_elem == runtime.to_seq(one_elem)
seqable = vec.v(kw.keyword("kw"))
assert seqable == runtime.to_seq(seqable)
v1 = vec.v(kw.keyword("kw"), 1, llist.l("something"), 3)
s1 = runtime.to_seq(v1)
assert isinstance(s1, ISeq)
for v, s in zip(v1, s1):
assert v == s
py_list = [1, 2, 3]
assert llist.l(1, 2, 3) == runtime.to_seq(py_list)
def test_var_watchers(ns_sym: sym.Symbol, var_name: sym.Symbol):
v = Var.intern(ns_sym, var_name, 0)
assert v is v.remove_watch("nonexistent-watch")
watcher1_key = kw.keyword("watcher-the-first")
watcher1_vals = []
def watcher1(k, ref, old, new):
assert watcher1_key is k
assert v is ref
watcher1_vals.append((old, new))
v.add_watch(watcher1_key, watcher1)
v.alter_root(lambda v: v * 2) # == 0
v.bind_root(4) # == 4
watcher2_key = kw.keyword("watcher-the-second")
watcher2_vals = []
def watcher2(k, ref, old, new):
assert watcher2_key is k
assert v is ref
watcher2_vals.append((old, new))
v.add_watch(watcher2_key, watcher2)
v.alter_root(lambda v: v * 2) # == 8
v.remove_watch(watcher1_key)
v.bind_root(10) # == 10
v.alter_root(lambda v: "a" * v) # == "aaaaaaaaaa"
assert [(0, 0), (0, 4), (4, 8)] == watcher1_vals
assert [(4, 8), (8, 10), (10, "aaaaaaaaaa")] == watcher2_vals
def test_seq_equals():
# to_seq should be first to ensure that `ISeq.__eq__` is used
assert runtime.to_seq(vec.v(1, 2, 3)) == llist.l(1, 2, 3)
assert False is (runtime.to_seq(vec.v(1, 2, 3)) == kw.keyword("abc"))
assert lseq.sequence(vec.v(1, 2, 3)) == llist.l(1, 2, 3)
assert False is (lseq.sequence(vec.v(1, 2, 3)) == kw.keyword("abc"))
def test_keyword_name_and_ns():
kw = keyword("kw", ns="ns")
assert kw.name == "kw"
assert kw.ns == "ns"
kw = keyword("kw")
assert kw.name == "kw"
assert kw.ns is None
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_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_literal_to_lisp(self):
assert None is runtime.to_lisp(None)
assert 1 == runtime.to_lisp(1)
assert 1.6 == runtime.to_lisp(1.6)
assert "string" == runtime.to_lisp("string")
assert sym.symbol("sym") == runtime.to_lisp(sym.symbol("sym"))
assert sym.symbol("sym", ns="ns") == runtime.to_lisp(sym.symbol("sym", ns="ns"))
assert kw.keyword("kw") == runtime.to_lisp(kw.keyword("kw"))
assert kw.keyword("kw", ns="ns") == runtime.to_lisp(kw.keyword("kw", ns="ns"))
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_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_keyword_str_and_repr():
kw = keyword("kw", ns="ns")
assert str(kw) == ":ns/kw"
assert repr(kw) == ":ns/kw"
kw = keyword("kw", ns="some.ns")
assert str(kw) == ":some.ns/kw"
assert repr(kw) == ":some.ns/kw"
kw = keyword("kw")
assert str(kw) == ":kw"
assert repr(kw) == ":kw"
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_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_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 ns(self) -> Namespace:
ns_sym = sym.symbol("test")
ns = Namespace(ns_sym)
str_ns_alias = sym.symbol("basilisp.string")
join_sym = sym.symbol("join")
chars_sym = sym.symbol("chars")
str_ns = Namespace(str_ns_alias)
str_ns.intern(join_sym, Var(ns, join_sym))
str_ns.intern(
chars_sym,
Var(ns, chars_sym, meta=lmap.map({kw.keyword("private"): True})))
ns.add_alias(str_ns, str_ns_alias)
str_alias = sym.symbol("str")
ns.add_alias(Namespace(str_alias), str_alias)
str_sym = sym.symbol("str")
ns.intern(str_sym, Var(ns, str_sym))
is_string_sym = sym.symbol("string?")
ns.intern(is_string_sym, Var(ns, is_string_sym))
time_sym = sym.symbol("time")
time_alias = sym.symbol("py-time")
ns.add_import(time_sym, __import__("time"), time_alias)
core_ns = Namespace(sym.symbol("basilisp.core"))
map_alias = sym.symbol("map")
ns.add_refer(map_alias, Var(core_ns, map_alias))
return ns
def test_refer_all(ns_cache: atom.Atom[NamespaceMap]):
ns1 = get_or_create_ns(sym.symbol("ns1"))
var_sym1, var_val1 = sym.symbol("useful-value"), "cool string"
var1 = Var(ns1, var_sym1)
var1.set_value(var_val1)
ns1.intern(var_sym1, var1)
var_sym2, var_val2 = sym.symbol("private-value"), "private string"
var2 = Var(ns1, var_sym2, meta=lmap.map({kw.keyword("private"): True}))
var2.set_value(var_val2)
ns1.intern(var_sym2, var2)
var_sym3, var_val3 = sym.symbol("existing-value"), "interned string"
var3 = Var(ns1, var_sym3)
var3.set_value(var_val3)
ns1.intern(var_sym3, var3)
ns2 = get_or_create_ns(sym.symbol("ns2"))
var_val4 = "some other value"
var4 = Var(ns2, var_sym3)
var4.set_value(var_val4)
ns2.intern(var_sym3, var4)
ns2.refer_all(ns1)
assert var1 is ns2.get_refer(var_sym1)
assert var1 is ns2.find(var_sym1)
assert var_val1 == ns2.find(var_sym1).value
assert None is ns2.get_refer(var_sym2)
assert None is ns2.find(var_sym2)
assert var3 is ns2.get_refer(var_sym3)
assert var4 is ns2.find(var_sym3)
assert var_val4 == ns2.find(var_sym3).value
def test_keyword_as_function():
kw = keyword("kw")
assert None is kw(None)
assert 1 == kw(lmap.map({kw: 1}))
assert "hi" == kw(lmap.map({kw: "hi"}))
assert None is kw(lmap.map({"hi": kw}))
def _validate(self, val: Any, vf: Optional[RefValidator] = None):
vf = vf or self._validator
if vf is not None:
try:
res = vf(val)
except Exception:
res = False
if not res:
raise ExceptionInfo(
"Invalid reference state",
lmap.map({
kw.keyword("data"): val,
kw.keyword("validator"): vf
}),
)
def test_dynamic_unbound(
ns_sym: sym.Symbol,
var_name: sym.Symbol,
):
v = Var.intern_unbound(ns_sym, var_name, dynamic=True)
assert isinstance(v, Var)
assert ns_sym.name == v.ns.name
assert var_name == v.name
assert not v.is_bound
assert v.dynamic
assert not v.is_thread_bound
assert Unbound(v) == v.root
assert Unbound(v) == v.value
assert Unbound(v) == v.deref()
new_val = kw.keyword("new-val")
try:
v.push_bindings(new_val)
assert v.is_bound
assert v.dynamic
assert v.is_thread_bound
assert Unbound(v) == v.root
assert new_val == v.value
assert new_val == v.deref()
finally:
v.pop_bindings()
assert not v.is_bound
ns = get_or_create_ns(ns_sym)
assert None is not ns
assert ns.find(var_name) == v
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_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_private_var(
ns_sym: sym.Symbol,
var_name: sym.Symbol,
intern_val,
):
v = Var.intern(ns_sym,
var_name,
intern_val,
meta=lmap.map({kw.keyword("private"): True}))
assert v.is_private
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_var_bindings_are_noop_for_non_dynamic_var(
ns_sym: sym.Symbol,
var_name: sym.Symbol,
intern_val,
):
v = Var.intern(ns_sym, var_name, intern_val)
assert v.is_bound
assert not v.dynamic
assert not v.is_thread_bound
assert intern_val == v.root
assert intern_val == v.value
assert intern_val == v.deref()
new_val = kw.keyword("new-val")
new_val2 = kw.keyword("other-new-val")
try:
with pytest.raises(RuntimeException):
v.push_bindings(new_val)
assert v.is_bound
assert not v.dynamic
assert not v.is_thread_bound
assert intern_val == v.root
assert intern_val == v.value
assert intern_val == v.deref()
v.set_value(new_val2)
assert v.is_bound
assert not v.dynamic
assert not v.is_thread_bound
assert new_val2 == v.root
assert new_val2 == v.value
assert new_val2 == v.deref()
finally:
with pytest.raises(RuntimeException):
v.pop_bindings()
assert v.is_bound
assert not v.dynamic
assert not v.is_thread_bound
assert new_val2 == v.root
assert new_val2 == v.value
assert new_val2 == v.deref()
def test_get():
assert None is runtime.get(None, "a")
assert kw.keyword("nada") is runtime.get(None, "a", kw.keyword("nada"))
assert None is runtime.get(3, "a")
assert kw.keyword("nada") is runtime.get(3, "a", kw.keyword("nada"))
assert 1 == runtime.get(lmap.map({"a": 1}), "a")
assert None is runtime.get(lmap.map({"a": 1}), "b")
assert 2 == runtime.get(lmap.map({"a": 1}), "b", 2)
assert 1 == runtime.get(lmap.map({"a": 1}).to_transient(), "a")
assert None is runtime.get(lmap.map({"a": 1}).to_transient(), "b")
assert 2 == runtime.get(lmap.map({"a": 1}).to_transient(), "b", 2)
assert 1 == runtime.get(vec.v(1, 2, 3), 0)
assert None is runtime.get(vec.v(1, 2, 3), 3)
assert "nada" == runtime.get(vec.v(1, 2, 3), 3, "nada")
assert 1 == runtime.get(vec.v(1, 2, 3).to_transient(), 0)
assert None is runtime.get(vec.v(1, 2, 3).to_transient(), 3)
assert "nada" == runtime.get(vec.v(1, 2, 3).to_transient(), 3, "nada")
assert "l" == runtime.get("hello world", 2)
assert None is runtime.get("hello world", 50)
assert "nada" == runtime.get("hello world", 50, "nada")
assert "l" == runtime.get(["h", "e", "l", "l", "o"], 2)
assert None is runtime.get(["h", "e", "l", "l", "o"], 50)
assert "nada" == runtime.get(["h", "e", "l", "l", "o"], 50, "nada")
assert 1 == runtime.get({"a": 1}, "a")
assert None is runtime.get({"a": 1}, "b")
assert 2 == runtime.get({"a": 1}, "b", 2)
assert "a" == runtime.get({"a", "b", "c"}, "a")
assert None is runtime.get({"a", "b", "c"}, "d")
assert 2 == runtime.get({"a", "b", "c"}, "d", 2)
assert "a" == runtime.get(frozenset({"a", "b", "c"}), "a")
assert None is runtime.get(frozenset({"a", "b", "c"}), "d")
assert 2 == runtime.get(frozenset({"a", "b", "c"}), "d", 2)
assert "a" == runtime.get(lset.set({"a", "b", "c"}), "a")
assert None is runtime.get(lset.set({"a", "b", "c"}), "d")
assert 2 == runtime.get(lset.set({"a", "b", "c"}), "d", 2)
assert "a" == runtime.get(lset.set({"a", "b", "c"}).to_transient(), "a")
assert None is runtime.get(lset.set({"a", "b", "c"}).to_transient(), "d")
assert 2 == runtime.get(lset.set({"a", "b", "c"}).to_transient(), "d", 2)
# lists are "supported" by virtue of the fact that `get`-ing them does not fail
assert None is runtime.get(llist.l(1, 2, 3), 0)
assert None is runtime.get(llist.l(1, 2, 3), 3)
assert "nada" == runtime.get(llist.l(1, 2, 3), 0, "nada")
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_cannot_refer_private(ns_cache: atom.Atom[NamespaceMap]):
ns1 = get_or_create_ns(sym.symbol("ns1"))
var_sym, var_val = sym.symbol("useful-value"), "cool string"
var = Var(ns1, var_sym, meta=lmap.map({kw.keyword("private"): True}))
var.set_value(var_val)
ns1.intern(var_sym, var)
ns2 = get_or_create_ns(sym.symbol("ns2"))
ns2.add_refer(var_sym, var)
assert None is ns2.get_refer(var_sym)
assert None is ns2.find(var_sym)
