165 lines
4.2 KiB
Python
165 lines
4.2 KiB
Python
import pytest
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_no_exists(state):
|
|
l = state.read_reverse_dict(-1, "abc")
|
|
assert l is None
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_not_found_node(state):
|
|
a = state.create_node()
|
|
assert a is not None
|
|
|
|
# Passing data is not enforced, as the data will be interpreted if necessary
|
|
l = state.read_reverse_dict(a, "abc")
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_not_found_nodevalue(state):
|
|
a = state.create_nodevalue(1)
|
|
assert a is not None
|
|
|
|
# Passing data is not enforced, as the data will be interpreted if necessary
|
|
l = state.read_reverse_dict(a, "abc")
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_not_found_edge(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_edge(a, b)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
|
|
# Passing data is not enforced, as the data will be interpreted if necessary
|
|
l = state.read_reverse_dict(c, "abc")
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_no_primitive(state):
|
|
a = state.create_node()
|
|
assert a is not None
|
|
|
|
# Passing data is not enforced, as the data will be interpreted if necessary
|
|
l = state.read_reverse_dict(a, a)
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_node_simple(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_nodevalue("f")
|
|
d = state.create_edge(a, b)
|
|
e = state.create_edge(d, c)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
assert d is not None
|
|
assert e is not None
|
|
|
|
l = state.read_reverse_dict(b, "f")
|
|
assert set(l) == set([a])
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_no_match(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_nodevalue("g")
|
|
d = state.create_edge(a, b)
|
|
e = state.create_edge(d, c)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
assert d is not None
|
|
assert e is not None
|
|
|
|
l = state.read_reverse_dict(b, "f")
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_node_multi(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_nodevalue("f")
|
|
d = state.create_edge(a, b)
|
|
e = state.create_edge(d, c)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
assert d is not None
|
|
assert e is not None
|
|
|
|
g = state.create_node()
|
|
h = state.create_nodevalue("k")
|
|
i = state.create_edge(a, g)
|
|
j = state.create_edge(i, h)
|
|
assert g is not None
|
|
assert h is not None
|
|
assert i is not None
|
|
assert j is not None
|
|
|
|
l = state.read_reverse_dict(b, "f")
|
|
assert set(l) == set([a])
|
|
|
|
l = state.read_reverse_dict(g, "k")
|
|
assert set(l) == set([a])
|
|
|
|
l = state.read_reverse_dict(a, "l")
|
|
assert l == []
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_node_multi_ambiguous(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_nodevalue("f")
|
|
d = state.create_edge(b, a)
|
|
e = state.create_edge(d, c)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
assert d is not None
|
|
assert e is not None
|
|
|
|
g = state.create_node()
|
|
h = state.create_nodevalue("f")
|
|
i = state.create_edge(g, a)
|
|
j = state.create_edge(i, h)
|
|
assert g is not None
|
|
assert h is not None
|
|
assert i is not None
|
|
assert j is not None
|
|
|
|
l = state.read_reverse_dict(a, "f")
|
|
assert set(l) == set([b, g])
|
|
|
|
|
|
@pytest.mark.usefixtures("state")
|
|
def test_read_reverse_dict_node_uncertain(state):
|
|
a = state.create_node()
|
|
b = state.create_node()
|
|
c = state.create_nodevalue("f")
|
|
d = state.create_edge(a, b)
|
|
e = state.create_edge(d, c)
|
|
assert a is not None
|
|
assert b is not None
|
|
assert c is not None
|
|
assert d is not None
|
|
assert e is not None
|
|
|
|
h = state.create_nodevalue("g")
|
|
i = state.create_edge(d, h)
|
|
assert h is not None
|
|
assert i is not None
|
|
|
|
l = state.read_reverse_dict(b, "f")
|
|
assert set(l) == set([a])
|