def test_cons():
assert llist.l(None) == runtime.cons(None, None)
assert llist.l(1) == runtime.cons(1, None)
assert llist.l(1) == runtime.cons(1, llist.l())
assert llist.l(1, 2, 3) == runtime.cons(1, llist.l(2, 3))
assert llist.l(1, 2, 3) == runtime.cons(1, vec.v(2, 3))
assert llist.l(1, 2, 3) == runtime.cons(1, vec.v(2, 3).seq())
def test_py_contains():
assert "a" in vec.v("a")
assert "a" in vec.v("a", "b")
assert "b" in vec.v("a", "b")
assert "c" not in vec.PersistentVector.empty()
assert "c" not in vec.v("a")
assert "c" not in vec.v("a", "b")
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_update():
assert lmap.map({"a": 1}) == runtime.update(None, "a", lambda _: 1)
assert lmap.map({"a": 50}) == runtime.update(None, "a", lambda _, x: x, 50)
assert lmap.map({"a": 2}) == runtime.update(
lmap.map({"a": 1}), "a", lambda x: x + 1
)
assert lmap.map({"a": 4}) == runtime.update(
lmap.map({"a": 1}), "a", lambda x, y: x * y + 1, 3
)
assert lmap.map({"a": 1, "b": "string"}) == runtime.update(
lmap.map({"a": 1}), "b", lambda _: "string"
)
assert lmap.map({"a": 1, "b": "string"}) == runtime.update(
lmap.map({"a": 1, "b": 583}), "b", lambda _: "string"
)
assert vec.v("a") == runtime.update(vec.PersistentVector.empty(), 0, lambda _: "a")
assert vec.v("yay", "b") == runtime.update(vec.v("a", "b"), 0, lambda x: f"y{x}y")
assert vec.v("a", "boy") == runtime.update(
vec.v("a", "b"), 1, lambda x, y: f"{x}{y}", "oy"
)
with pytest.raises(TypeError):
runtime.update(llist.PersistentList.empty(), 1, lambda _: "y")
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_val_at():
assert "a" == vec.v("a").val_at(0)
assert "b" == vec.v("a", "b").val_at(1)
assert None is vec.v("a", "b").val_at(2)
assert "b" == vec.v("a", "b").val_at(-1)
assert None is vec.PersistentVector.empty().val_at(0)
assert None is vec.PersistentVector.empty().val_at(1)
assert None is vec.PersistentVector.empty().val_at(-1)
def test_contains():
assert True is vec.v("a").contains(0)
assert True is vec.v("a", "b").contains(1)
assert False is vec.v("a", "b").contains(2)
assert False is vec.v("a", "b").contains(-1)
assert False is vec.PersistentVector.empty().contains(0)
assert False is vec.PersistentVector.empty().contains(1)
assert False is vec.PersistentVector.empty().contains(-1)
def test_rest():
assert lseq.EMPTY is runtime.rest(None)
assert lseq.EMPTY is runtime.rest(llist.l())
assert lseq.EMPTY is runtime.rest(llist.l(1))
assert llist.l(2, 3) == runtime.rest(llist.l(1, 2, 3))
assert lseq.EMPTY is runtime.rest(vec.v(1).seq())
assert lseq.EMPTY is runtime.rest(vec.v(1))
assert llist.l(2, 3) == runtime.rest(vec.v(1, 2, 3))
def test_entry():
assert vec.MapEntry.of(0, "a") == vec.v("a").entry(0)
assert vec.MapEntry.of(1, "b") == vec.v("a", "b").entry(1)
assert None is vec.v("a", "b").entry(2)
assert vec.MapEntry.of(-1, "b") == vec.v("a", "b").entry(-1)
assert None is vec.PersistentVector.empty().entry(0)
assert None is vec.PersistentVector.empty().entry(1)
assert None is vec.PersistentVector.empty().entry(-1)
def test_next():
assert None is runtime.next_(None)
assert None is runtime.next_(llist.l())
assert None is runtime.next_(llist.l(1))
assert llist.l(2, 3) == runtime.next_(llist.l(1, 2, 3))
assert None is runtime.next_(vec.v(1).seq())
assert None is runtime.next_(vec.v(1))
assert llist.l(2, 3) == runtime.next_(vec.v(1, 2, 3))
def test_first():
assert None is runtime.first(None)
assert None is runtime.first(llist.l())
assert 1 == runtime.first(llist.l(1))
assert 1 == runtime.first(llist.l(1, 2, 3))
assert 1 == runtime.first(vec.v(1).seq())
assert 1 == runtime.first(vec.v(1))
assert 1 == runtime.first(vec.v(1, 2, 3))
def test_assoc():
v = vec.PersistentVector.empty()
assert vec.v("a") == v.assoc(0, "a")
assert vec.PersistentVector.empty() == v
assert vec.vector(["a", "b"]) == v.assoc(0, "a", 1, "b")
v1 = vec.v("a")
assert vec.v("c", "b") == v1.assoc(0, "c", 1, "b")
assert vec.v("a", "b") == v1.assoc(1, "b")
def test_to_vec(self):
assert vec.PersistentVector.empty() == runtime.to_lisp([])
assert vec.v("a", 2) == runtime.to_lisp(["a", 2])
assert vec.v("a", 2, None) == runtime.to_lisp(["a", 2, None])
assert vec.PersistentVector.empty() == runtime.to_lisp(
vec.PersistentVector.empty()
)
assert vec.v("a", 2) == runtime.to_lisp(("a", 2))
assert vec.v("a", 2, None) == runtime.to_lisp(("a", 2, None))
def test_to_list(self):
assert [] == runtime.to_py(llist.PersistentList.empty())
assert ["a", 2] == runtime.to_py(llist.l("a", 2))
assert ["a", 2, None] == runtime.to_py(llist.l("a", 2, None))
assert [] == runtime.to_py(vec.PersistentVector.empty())
assert ["a", 2] == runtime.to_py(vec.v("a", 2))
assert ["a", 2, None] == runtime.to_py(vec.v("a", 2, None))
assert None is runtime.to_py(runtime.to_seq(vec.PersistentVector.empty()))
assert ["a", 2] == runtime.to_py(runtime.to_seq(vec.v("a", 2)))
assert ["a", 2, None] == runtime.to_py(runtime.to_seq(vec.v("a", 2, None)))
def test_apply():
assert vec.v() == runtime.apply(vec.v, [[]])
assert vec.v(1, 2, 3) == runtime.apply(vec.v, [[1, 2, 3]])
assert vec.v(None, None, None) == runtime.apply(vec.v, [[None, None, None]])
assert vec.v(vec.v(1, 2, 3), 4, 5, 6) == runtime.apply(
vec.v, [vec.v(1, 2, 3), [4, 5, 6]]
)
assert vec.v(vec.v(1, 2, 3), None, None, None) == runtime.apply(
vec.v, [vec.v(1, 2, 3), [None, None, None]]
)
def test_delay(capsys):
d = delay.Delay(lambda: vec.v(print("In Delay Now"), 1, 2, 3))
assert False is d.is_realized
assert vec.v(None, 1, 2, 3) == d.deref()
captured = capsys.readouterr()
assert "In Delay Now\n" == captured.out
assert True is d.is_realized
assert vec.v(None, 1, 2, 3) == d.deref()
captured = capsys.readouterr()
assert "" == captured.out
assert True is d.is_realized
def test_atom():
a = atom.Atom(vec.PersistentVector.empty())
assert vec.PersistentVector.empty() == a.deref()
assert vec.v(1) == a.swap(lambda v, e: v.cons(e), 1)
assert vec.v(1) == a.deref()
assert vec.v(1, 2) == a.swap(lambda v, e: v.cons(e), 2)
assert vec.v(1, 2) == a.deref()
assert lmap.PersistentMap.empty() == a.reset(lmap.PersistentMap.empty())
assert lmap.PersistentMap.empty() == a.deref()
assert False is a.compare_and_set("not a map", vec.PersistentVector.empty())
assert True is a.compare_and_set(lmap.PersistentMap.empty(), "new string")
assert "new string" == a.deref()
def test_assoc():
assert lmap.PersistentMap.empty() == runtime.assoc(None)
assert lmap.map({"a": 1}) == runtime.assoc(None, "a", 1)
assert lmap.map({"a": 8}) == runtime.assoc(lmap.map({"a": 1}), "a", 8)
assert lmap.map({"a": 1, "b": "string"}) == runtime.assoc(
lmap.map({"a": 1}), "b", "string"
)
assert vec.v("a") == runtime.assoc(vec.PersistentVector.empty(), 0, "a")
assert vec.v("c", "b") == runtime.assoc(vec.v("a", "b"), 0, "c")
assert vec.v("a", "c") == runtime.assoc(vec.v("a", "b"), 1, "c")
with pytest.raises(IndexError):
runtime.assoc(vec.PersistentVector.empty(), 1, "a")
with pytest.raises(TypeError):
runtime.assoc(llist.PersistentList.empty(), 1, "a")
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_pop():
with pytest.raises(IndexError):
vec.v().pop()
assert vec.PersistentVector.empty() == vec.v(1).pop()
assert vec.v(1) == vec.v(1, 2).pop()
assert vec.v(1, 2) == vec.v(1, 2, 3).pop()
def test_nthnext():
assert None is runtime.nthnext(None, 1)
assert None is runtime.nthnext(llist.PersistentList.empty(), 0)
assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthnext(
llist.l(1, 2, 3, 4, 5, 6), 1
)
assert lseq.sequence([3, 4, 5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 2)
assert lseq.sequence([4, 5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 3)
assert lseq.sequence([5, 6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 4)
assert lseq.sequence([6]) == runtime.nthnext(llist.l(1, 2, 3, 4, 5, 6), 5)
assert None is runtime.nthnext(vec.PersistentVector.empty(), 0)
assert lseq.sequence([2, 3, 4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 1)
assert lseq.sequence([3, 4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 2)
assert lseq.sequence([4, 5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 3)
assert lseq.sequence([5, 6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 4)
assert lseq.sequence([6]) == runtime.nthnext(vec.v(1, 2, 3, 4, 5, 6), 5)
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_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_concat():
s1 = runtime.concat()
assert lseq.EMPTY is s1
s1 = runtime.concat(llist.PersistentList.empty(), llist.PersistentList.empty())
assert lseq.EMPTY == s1
s1 = runtime.concat(llist.PersistentList.empty(), llist.l(1, 2, 3))
assert s1 == llist.l(1, 2, 3)
s1 = runtime.concat(llist.l(1, 2, 3), vec.v(4, 5, 6))
assert s1 == llist.l(1, 2, 3, 4, 5, 6)
def test_nth():
assert None is runtime.nth(None, 1)
assert "not found" == runtime.nth(None, 4, "not found")
assert "l" == runtime.nth("hello world", 2)
assert "l" == runtime.nth(["h", "e", "l", "l", "o"], 2)
assert "l" == runtime.nth(llist.l("h", "e", "l", "l", "o"), 2)
assert "l" == runtime.nth(vec.v("h", "e", "l", "l", "o"), 2)
assert "l" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 2)
assert "Z" == runtime.nth(llist.l("h", "e", "l", "l", "o"), 7, "Z")
assert "Z" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 7, "Z")
assert "Z" == runtime.nth(vec.v("h", "e", "l", "l", "o"), 7, "Z")
with pytest.raises(IndexError):
runtime.nth(llist.l("h", "e", "l", "l", "o"), 7)
with pytest.raises(IndexError):
runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 7)
with pytest.raises(IndexError):
runtime.nth(vec.v("h", "e", "l", "l", "o"), 7)
with pytest.raises(TypeError):
runtime.nth(lmap.PersistentMap.empty(), 2)
with pytest.raises(TypeError):
runtime.nth(lmap.map({"a": 1, "b": 2, "c": 3}), 2)
with pytest.raises(TypeError):
runtime.nth(lset.PersistentSet.empty(), 2)
with pytest.raises(TypeError):
runtime.nth(lset.s(1, 2, 3), 2)
with pytest.raises(TypeError):
runtime.nth(3, 1)
with pytest.raises(TypeError):
runtime.nth(3, 1, "Z")
def test_map_seq():
assert None is lmap.PersistentMap.empty().seq()
assert {v("a", 1)} == set(lmap.map({"a": 1}).seq())
assert {v("a", 1), v("b", 2)} == set(lmap.map({"a": 1, "b": 2}).seq())
assert {v("a", 1), v("b", 2),
v("c", 3)} == set(lmap.map({
"a": 1,
"b": 2,
"c": 3
}).seq())
def test_conj():
assert llist.l(1) == runtime.conj(None, 1)
assert llist.l(3, 2, 1) == runtime.conj(None, 1, 2, 3)
assert llist.l(llist.l(1, 2, 3)) == runtime.conj(None, llist.l(1, 2, 3))
assert llist.l(1) == runtime.conj(llist.PersistentList.empty(), 1)
assert llist.l(3, 2, 1) == runtime.conj(llist.PersistentList.empty(), 1, 2, 3)
assert llist.l(3, 2, 1, 1) == runtime.conj(llist.l(1), 1, 2, 3)
assert llist.l(llist.l(1, 2, 3), 1) == runtime.conj(llist.l(1), llist.l(1, 2, 3))
assert lset.s(1) == runtime.conj(lset.PersistentSet.empty(), 1)
assert lset.s(1, 2, 3) == runtime.conj(lset.PersistentSet.empty(), 1, 2, 3)
assert lset.s(1, 2, 3) == runtime.conj(lset.s(1), 1, 2, 3)
assert lset.s(1, lset.s(1, 2, 3)) == runtime.conj(lset.s(1), lset.s(1, 2, 3))
assert vec.v(1) == runtime.conj(vec.PersistentVector.empty(), 1)
assert vec.v(1, 2, 3) == runtime.conj(vec.PersistentVector.empty(), 1, 2, 3)
assert vec.v(1, 1, 2, 3) == runtime.conj(vec.v(1), 1, 2, 3)
assert vec.v(1, vec.v(1, 2, 3)) == runtime.conj(vec.v(1), vec.v(1, 2, 3))
assert lmap.map({"a": 1}) == runtime.conj(lmap.PersistentMap.empty(), ["a", 1])
assert lmap.map({"a": 1, "b": 93}) == runtime.conj(
lmap.PersistentMap.empty(), ["a", 1], ["b", 93]
)
assert lmap.map({"a": 1, "b": 93}) == runtime.conj(
lmap.map({"a": 8}), ["a", 1], ["b", 93]
)
with pytest.raises(ValueError):
runtime.conj(lmap.map({"a": 8}), "a", 1, "b", 93)
with pytest.raises(TypeError):
runtime.conj(3, 1, "a")
with pytest.raises(TypeError):
runtime.conj("b", 1, "a")
def test_promise():
v = vec.v(1, 2, 3)
p = Promise()
assert False is p.is_realized
def set_promise():
p.deliver(v)
assert "not set yet" == p.deref(timeout=0.2, timeout_val="not set yet")
assert False is p.is_realized
t = threading.Thread(target=set_promise)
t.start()
t.join()
assert v == p.deref()
assert True is p.is_realized
p.deliver("another value")
assert v == p.deref()
assert True is p.is_realized
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 intern_val():
return vec.v(kw.keyword("value"))
