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_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_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_to_sequence():
assert lseq.EMPTY is lseq.sequence([])
assert lseq.sequence([]).is_empty
assert llist.l(None) == lseq.sequence([None])
assert not lseq.sequence([None]).is_empty
assert llist.l(1) == lseq.sequence([1])
assert not lseq.sequence([1]).is_empty
assert llist.l(1, 2, 3) == lseq.sequence([1, 2, 3])
assert not lseq.sequence([1, 2, 3]).is_empty
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_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_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_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_sequence():
s = lseq.sequence([1])
assert not s.is_empty
assert 1 == s.first
assert lseq.EMPTY is s.rest
assert llist.l(2, 1) == s.cons(2)
assert [1, 2, 3] == [e for e in lseq.sequence([1, 2, 3])]
assert llist.l(1, 2, 3) == lseq.sequence([1, 2, 3])
assert llist.l(1, 2, 3) == lseq.sequence(llist.l(1, 2, 3))
assert llist.l(1, 2, 3) == llist.list(lseq.sequence([1, 2, 3]))
s = lseq.sequence([1, 2, 3])
assert not s.is_empty
assert 2 == s.rest.first
assert 3 == s.rest.rest.first
assert None is s.rest.rest.rest.first
def test_empty_sequence():
empty = lseq.sequence([])
assert empty.is_empty
assert None is empty.first
assert empty.rest == empty
assert llist.l(1) == empty.cons(1)
assert lseq.EMPTY is empty
assert True is bool(lseq.sequence([]))
def test_pop():
with pytest.raises(IndexError):
llist.l().pop()
assert llist.PersistentList.empty() == llist.l(1).pop()
assert llist.l(2) == llist.l(1, 2).pop()
assert llist.l(2, 3) == llist.l(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_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_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_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_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_trampoline_args():
args = runtime._TrampolineArgs(True)
assert () == args.args
args = runtime._TrampolineArgs(False, llist.l(2, 3, 4))
assert (llist.l(2, 3, 4),) == args.args
args = runtime._TrampolineArgs(True, llist.l(2, 3, 4))
assert (2, 3, 4) == args.args
args = runtime._TrampolineArgs(False, 1, 2, 3, llist.l(4, 5, 6))
assert (1, 2, 3, llist.l(4, 5, 6)) == args.args
args = runtime._TrampolineArgs(True, 1, 2, 3, llist.l(4, 5, 6))
assert (1, 2, 3, 4, 5, 6) == args.args
args = runtime._TrampolineArgs(True, 1, llist.l(2, 3, 4), 5, 6)
assert (1, llist.l(2, 3, 4), 5, 6) == args.args
assert None is llist.l().first
assert 1 == llist.l(1).first
assert 1 == llist.l(1, 2).first
def test_list_rest():
assert llist.l().rest == llist.l()
assert llist.l(keyword("kw1")).rest == llist.l()
assert llist.l(keyword("kw1"),
keyword("kw2")).rest == llist.l(keyword("kw2"))
@pytest.mark.parametrize(
"o",
[
llist.l(),
llist.l(keyword("kw1")),
llist.l(keyword("kw1"), 2),
llist.l(keyword("kw1"), 2, None, "nothingness"),
llist.l(keyword("kw1"), llist.l("string", 4)),
],
)
def test_list_pickleability(pickle_protocol: int, o: llist.PersistentList):
assert o == pickle.loads(pickle.dumps(o, protocol=pickle_protocol))
@pytest.mark.parametrize(
"l,str_repr",
[
(llist.l(), "()"),
(llist.l(keyword("kw1")), "(:kw1)"),
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_list_first():
assert None is llist.PersistentList.empty().first
assert None is llist.l().first
assert 1 == llist.l(1).first
assert 1 == llist.l(1, 2).first
def test_list_interface_membership(interface):
assert isinstance(llist.l(), interface)
assert issubclass(llist.PersistentList, interface)
def test_list_rest():
assert llist.l().rest == llist.l()
assert llist.l(keyword("kw1")).rest == llist.l()
assert llist.l(keyword("kw1"),
keyword("kw2")).rest == llist.l(keyword("kw2"))
def test_list_slice():
assert isinstance(llist.l(1, 2, 3)[1:], llist.PersistentList)
def test_peek():
assert None is llist.l().peek()
assert 1 == llist.l(1).peek()
assert 1 == llist.l(1, 2).peek()
assert 1 == llist.l(1, 2, 3).peek()
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_list_seq():
assert None is llist.PersistentList.empty().seq()
assert llist.l(1) == llist.l(1).seq()
assert llist.l(1, 2) == llist.l(1, 2).seq()
assert llist.l(1, 2, 3) == llist.l(1, 2, 3).seq()
(-1, -1),
(0.0, 0.0),
(1.0, 1.0),
(-1.0, -1.0),
(0.0, 0),
(1.0, 1),
(-1.0, -1),
(True, True),
(False, False),
(None, None),
("", ""),
("not empty", "not empty"),
(Fraction("1/2"), Fraction("1/2")),
(Decimal("3.14159"), Decimal("3.14159")),
(llist.PersistentList.empty(), llist.PersistentList.empty()),
(llist.l(1, 2, 3), llist.l(1, 2, 3)),
(lmap.PersistentMap.empty(), lmap.PersistentMap.empty()),
(lmap.map({"a": 1, "b": 2}), lmap.map({"a": 1, "b": 2})),
(lset.PersistentSet.empty(), lset.PersistentSet.empty()),
(lqueue.PersistentQueue.empty(), lqueue.PersistentQueue.empty()),
(lqueue.q(1, 2, 3), lqueue.q(1, 2, 3)),
(lset.s(1, 2, 3), lset.s(1, 2, 3)),
(vec.PersistentVector.empty(), vec.PersistentVector.empty()),
(vec.v(1, 2, 3), vec.v(1, 2, 3)),
(lseq.EMPTY, lseq.EMPTY),
(lseq.EMPTY.cons(3).cons(2).cons(1), lseq.EMPTY.cons(3).cons(2).cons(1)),
(lqueue.q(1, 2, 3), lseq.EMPTY.cons(3).cons(2).cons(1)),
(vec.v(1, 2, 3), lseq.EMPTY.cons(3).cons(2).cons(1)),
(llist.PersistentList.empty(), vec.PersistentVector.empty()),
(llist.l(1, 2, 3), vec.v(1, 2, 3)),
(lseq.EMPTY, vec.PersistentVector.empty()),
