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)