teaching/muMLE
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

replace everywhere: 'is [not] None' -> '(==|!=) None'

Browse source
This commit is contained in:
Joeri Exelmans 2024-09-04 09:50:30 +02:00
parent 3ae35a87d0
commit ec1a9dbfca
28 changed files with 690 additions and 668 deletions
Download patch file Download diff file Expand all files Collapse all files

2
state/devstate.py
View file

@ -42,7 +42,7 @@ class DevState(PyState):
f.write("\"a_%s\" -> \"a_%s\";\n" % (i.int, e[1].int))
f.write("}")
if png_path is not None:
if png_path != None:
# generate png from dot-file
bashCommand = f"dot -Tpng {path} -o {png_path}"
import subprocess

48
state/neo4jstate.py
View file

@ -48,7 +48,7 @@ class Neo4jState(State):
return result.single()[0]
node = self._run_and_return(query, nid=str(self.new_id()))
return UUID(node) if node is not None else None
return UUID(node) if node != None else None
def create_edge(self, source: Element, target: Element) -> Optional[Edge]:
def query(tx, eid, sid, tid):
@ -66,7 +66,7 @@ class Neo4jState(State):
return None
edge = self._run_and_return(query, eid=str(self.new_id()), sid=str(source), tid=str(target))
return UUID(edge) if edge is not None else None
return UUID(edge) if edge != None else None
def create_nodevalue(self, value: Any) -> Optional[Node]:
def query(tx, nid, val):
@ -80,7 +80,7 @@ class Neo4jState(State):
return None
node = self._run_and_return(query, nid=str(self.new_id()), val=repr(value))
return UUID(node) if node is not None else None
return UUID(node) if node != None else None
def create_dict(self, source: Element, value: Any, target: Element) -> Optional[Tuple[Edge, Edge, Node]]:
if not self.is_valid_datavalue(value):
@ -88,7 +88,7 @@ class Neo4jState(State):
edge_node = self.create_edge(source, target)
val_node = self.create_nodevalue(value)
if edge_node is not None and val_node is not None:
if edge_node != None and val_node != None:
self.create_edge(edge_node, val_node)
def read_root(self) -> Node:
@ -107,7 +107,7 @@ class Neo4jState(State):
return None
value = self._run_and_return(query, nid=str(node))
return literal_eval(value) if value is not None else None
return literal_eval(value) if value != None else None
def read_outgoing(self, elem: Element) -> Optional[List[Edge]]:
def query(tx, eid):
@ -117,10 +117,10 @@ class Neo4jState(State):
eid=eid)
return result.value()
source_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
source_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if source_exists:
result = self._run_and_return(query, eid=str(elem))
return [UUID(x) for x in result] if result is not None else None
return [UUID(x) for x in result] if result != None else None
def read_incoming(self, elem: Element) -> Optional[List[Edge]]:
def query(tx, eid):
@ -130,10 +130,10 @@ class Neo4jState(State):
eid=eid)
return result.value()
target_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
target_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if target_exists:
result = self._run_and_return(query, eid=str(elem))
return [UUID(x) for x in result] if result is not None else None
return [UUID(x) for x in result] if result != None else None
def read_edge(self, edge: Edge) -> Tuple[Optional[Node], Optional[Node]]:
def query(tx, eid):
@ -143,7 +143,7 @@ class Neo4jState(State):
eid=eid)
return result.single()
edge_exists = self._run_and_return(self._existence_check, eid=str(edge), label="Edge") is not None
edge_exists = self._run_and_return(self._existence_check, eid=str(edge), label="Edge") != None
if edge_exists:
try:
src, tgt = self._run_and_return(query, eid=str(edge))
@ -167,12 +167,12 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
if isinstance(value, UUID):
return None
result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
return UUID(result) if result is not None else None
return UUID(result) if result != None else None
def read_dict_keys(self, elem: Element) -> Optional[List[Any]]:
def query(tx, eid):
@ -187,10 +187,10 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
result = self._run_and_return(query, eid=str(elem))
return [UUID(x) for x in result if x is not None]
return [UUID(x) for x in result if x != None]
def read_dict_edge(self, elem: Element, value: Any) -> Optional[Edge]:
def query(tx, eid, label_value):
@ -206,10 +206,10 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
return UUID(result) if result is not None else None
return UUID(result) if result != None else None
def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]:
def query(tx, eid, label_id):
@ -225,10 +225,10 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
result = self._run_and_return(query, eid=str(elem), label_id=str(value_node))
return UUID(result) if result is not None else None
return UUID(result) if result != None else None
def read_dict_node_edge(self, elem: Element, value_node: Node) -> Optional[Edge]:
def query(tx, eid, label_id):
@ -244,10 +244,10 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
result = self._run_and_return(query, eid=str(elem), label_id=str(value_node))
return UUID(result) if result is not None else None
return UUID(result) if result != None else None
def read_reverse_dict(self, elem: Element, value: Any) -> Optional[List[Element]]:
def query(tx, eid, label_value):
@ -263,10 +263,10 @@ class Neo4jState(State):
# No edge found with given label
return None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) is not None
elem_exists = self._run_and_return(self._existence_check, eid=str(elem)) != None
if elem_exists:
result = self._run_and_return(query, eid=str(elem), label_value=repr(value))
return [UUID(x) for x in result if x is not None]
return [UUID(x) for x in result if x != None]
def delete_node(self, node: Node) -> None:
def query(tx, nid):
@ -279,7 +279,7 @@ class Neo4jState(State):
return result.value()
to_be_deleted = self._run_and_return(query, nid=str(node))
to_be_deleted = [UUID(x) for x in to_be_deleted if x is not None]
to_be_deleted = [UUID(x) for x in to_be_deleted if x != None]
for edge in to_be_deleted:
self.delete_edge(edge)
@ -296,6 +296,6 @@ class Neo4jState(State):
return result.value()
to_be_deleted = self._run_and_return(query, eid=str(edge))
to_be_deleted = [UUID(x) for x in to_be_deleted if x is not None]
to_be_deleted = [UUID(x) for x in to_be_deleted if x != None]
for edge in to_be_deleted:
self.delete_edge(edge)

6
state/pystate.py
View file

@ -67,7 +67,7 @@ class PyState(State):
else:
n = self.create_nodevalue(value)
e = self.create_edge(source, target)
assert n is not None and e is not None
assert n != None and e != None
e2 = self.create_edge(e, n)
self.cache.setdefault(source, {})[value] = e
self.cache_node.setdefault(source, {})[n] = e
@ -107,7 +107,7 @@ class PyState(State):
def read_dict(self, elem: Element, value: Any) -> Optional[Element]:
e = self.read_dict_edge(elem, value)
if e is None:
if e == None:
return None
else:
return self.edges[e][1]
@ -142,7 +142,7 @@ class PyState(State):
def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]:
e = self.read_dict_node_edge(elem, value_node)
if e is None:
if e == None:
return None
else:
self.cache_node.setdefault(elem, {})[value_node] = e

18
state/test/test_create_dict.py
View file

@ -5,11 +5,11 @@ import pytest
def test_create_dict_simple(state):
id1 = state.create_node()
id2 = state.create_node()
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
n = state.create_dict(id1, "abc", id2)
assert n is None
assert n == None
v = state.read_dict(id1, "abc")
assert v == id2
@ -19,23 +19,23 @@ def test_create_dict_simple(state):
def test_create_dict_no_source(state):
id1 = 100000
id2 = state.create_node()
assert id2 is not None
assert id2 != None
n = state.create_dict(id1, "abc", id2)
assert n is None
assert n == None
v = state.read_dict(id1, "abc")
assert v is None
assert v == None
@pytest.mark.usefixtures("state")
def test_create_dict_no_target(state):
id2 = 100000
id1 = state.create_node()
assert id1 is not None
assert id1 != None
n = state.create_dict(id1, "abc", id2)
assert n is None
assert n == None
v = state.read_dict(id1, "abc")
assert v is None
assert v == None

66
state/test/test_create_edge.py
View file

@ -5,20 +5,20 @@ import pytest
def test_create_edge_invalid_source(state):
a = -1
b = state.create_node()
assert b is not None
assert b != None
e = state.create_edge(a, b)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
def test_create_edge_invalid_target(state):
b = -1
a = state.create_node()
assert a is not None
assert a != None
e = state.create_edge(a, b)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
@ -26,32 +26,32 @@ def test_create_edge_invalid_both(state):
a = -1
b = -1
e = state.create_edge(a, b)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
def test_create_edge_node_to_node(state):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge = state.create_edge(a, b)
assert edge is not None
assert edge != None
@pytest.mark.usefixtures("state")
def test_create_edge_multiple(state):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge1 = state.create_edge(a, b)
assert edge1 is not None
assert edge1 != None
edge2 = state.create_edge(a, b)
assert edge2 is not None
assert edge2 != None
assert edge1 != edge2
@ -61,12 +61,12 @@ def test_create_edge_many(state):
v = set()
for i in range(1000):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge = state.create_edge(a, b)
assert edge is not None
assert edge != None
v.add(edge)
assert len(v) == 1000
@ -75,15 +75,15 @@ def test_create_edge_many(state):
@pytest.mark.usefixtures("state")
def test_create_edge_edge_to_node(state):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge1 = state.create_edge(a, b)
assert edge1 is not None
assert edge1 != None
edge2 = state.create_edge(edge1, b)
assert edge2 is not None
assert edge2 != None
assert edge1 != edge2
@ -91,15 +91,15 @@ def test_create_edge_edge_to_node(state):
@pytest.mark.usefixtures("state")
def test_create_edge_node_to_edge(state):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge1 = state.create_edge(a, b)
assert edge1 is not None
assert edge1 != None
edge2 = state.create_edge(a, edge1)
assert edge2 is not None
assert edge2 != None
assert edge1 != edge2
@ -107,38 +107,38 @@ def test_create_edge_node_to_edge(state):
@pytest.mark.usefixtures("state")
def test_create_edge_edge_to_edge(state):
a = state.create_node()
assert a is not None
assert a != None
b = state.create_node()
assert b is not None
assert b != None
edge1 = state.create_edge(a, b)
assert edge1 is not None
assert edge1 != None
edge2 = state.create_edge(a, b)
assert edge2 is not None
assert edge2 != None
assert edge1 != edge2
edge3 = state.create_edge(edge1, edge2)
assert edge3 is not None
assert edge3 != None
@pytest.mark.usefixtures("state")
def test_create_edge_loop_node(state):
a = state.create_node()
assert a is not None
assert a != None
edge = state.create_edge(a, a)
assert edge is not None
assert edge != None
@pytest.mark.usefixtures("state")
def test_create_edge_loop_edge(state):
a = state.create_node()
assert a is not None
assert a != None
edge1 = state.create_edge(a, a)
assert edge1 is not None
assert edge1 != None
edge2 = state.create_edge(edge1, edge1)
assert edge2 is not None
assert edge2 != None

6
state/test/test_create_node.py
View file

@ -4,9 +4,9 @@ import pytest
@pytest.mark.usefixtures("state")
def test_create_node_different_id_simple(state):
id1 = state.create_node()
assert id1 is not None
assert id1 != None
id2 = state.create_node()
assert id2 is not None
assert id2 != None
assert id1 != id2
@ -16,7 +16,7 @@ def test_create_node_different_id_long(state):
results = set()
for i in range(1000):
v = state.create_node()
assert v is not None
assert v != None
results.add(v)
assert len(results) == 1000

44
state/test/test_create_nodevalue.py
View file

@ -6,15 +6,15 @@ def test_create_nodevalue_different_id_simple(state):
id1 = state.create_nodevalue(1)
id2 = state.create_nodevalue(1)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
assert id1 != id2
@pytest.mark.usefixtures("state")
def test_create_nodevalue_read(state):
id1 = state.create_nodevalue(1)
assert id1 is not None
assert id1 != None
val = state.read_value(id1)
assert val == 1
@ -26,7 +26,7 @@ def test_create_nodevalue_integer_ib_zero(state):
size = 0
for i in range(-10, 10):
id1 = state.create_nodevalue(i)
assert id1 is not None
assert id1 != None
size += 1
v.add(id1)
assert len(v) == size
@ -37,8 +37,8 @@ def test_create_nodevalue_boolean(state):
id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(False)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
assert id1 != id2
@ -47,15 +47,15 @@ def test_create_nodevalue_boolean_same(state):
id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(True)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
assert id1 != id2
@pytest.mark.usefixtures("state")
def test_create_nodevalue_float_keeps_type(state):
id1 = state.create_nodevalue(0.0)
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == float
@ -65,7 +65,7 @@ def test_create_nodevalue_float_keeps_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_string_empty(state):
id1 = state.create_nodevalue("")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
@ -75,7 +75,7 @@ def test_create_nodevalue_string_empty(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_string_normal(state):
id1 = state.create_nodevalue("ABC")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
@ -85,28 +85,28 @@ def test_create_nodevalue_string_normal(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_string_not_parsed(state):
id1 = state.create_nodevalue("1")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
assert v == "1"
id1 = state.create_nodevalue("1.0")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
assert v == "1.0"
id1 = state.create_nodevalue("-1.0")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
assert v == "-1.0"
id1 = state.create_nodevalue("True")
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert type(v) == str
@ -119,13 +119,13 @@ def test_create_nodevalue_junk(state):
pass
n = state.create_nodevalue(Unknown())
assert n is None
assert n == None
@pytest.mark.usefixtures("state")
def test_create_nodevalue_type_type(state):
id1 = state.create_nodevalue(("Type",))
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == ("Type",)
@ -134,7 +134,7 @@ def test_create_nodevalue_type_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_integer_type(state):
id1 = state.create_nodevalue(("Integer",))
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == ("Integer",)
@ -143,7 +143,7 @@ def test_create_nodevalue_integer_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_float_type(state):
id1 = state.create_nodevalue(("Float",))
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == ("Float",)
@ -152,7 +152,7 @@ def test_create_nodevalue_float_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_boolean_type(state):
id1 = state.create_nodevalue(("Boolean",))
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == ("Boolean",)
@ -161,7 +161,7 @@ def test_create_nodevalue_boolean_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_string_type(state):
id1 = state.create_nodevalue(("String",))
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == ("String",)
@ -170,4 +170,4 @@ def test_create_nodevalue_string_type(state):
@pytest.mark.usefixtures("state")
def test_create_nodevalue_invalid_type(state):
id1 = state.create_nodevalue(("Class",))
assert id1 is None
assert id1 == None

222
state/test/test_delete_edge.py
View file

@ -4,25 +4,25 @@ import pytest
@pytest.mark.usefixtures("state")
def test_delete_edge_no_exists(state):
e = state.delete_edge(1)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
def test_delete_edge_node(state):
a = state.create_node()
assert a is not None
assert a != None
e = state.delete_edge(a)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
def test_delete_edge_nodevalue(state):
a = state.create_nodevalue(1)
assert a is not None
assert a != None
e = state.delete_edge(a)
assert e is None
assert e == None
@pytest.mark.usefixtures("state")
@ -30,27 +30,27 @@ def test_delete_edge_normal(state):
a = state.create_nodevalue(1)
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
assert a != None
assert b != None
assert c != None
n = state.delete_edge(c)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -60,35 +60,35 @@ def test_delete_edge_remove_recursive(state):
b = state.create_node()
c = state.create_edge(a, b)
d = state.create_edge(c, b)
assert a is not None
assert b is not None
assert c is not None
assert d is not None
assert a != None
assert b != None
assert c != None
assert d != None
n = state.delete_edge(c)
assert n is None
assert n == None
l = state.read_value(a)
assert l == 1
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(c)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(d)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -102,60 +102,60 @@ def test_delete_edge_remove_edge_recursive_deep(state):
f = state.create_node()
g = state.create_edge(f, e)
h = state.create_edge(b, 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
assert f is not None
assert g is not None
assert h is not None
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
assert f != None
assert g != None
assert h != None
n = state.delete_edge(d)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([h])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([h])
s, t = state.read_edge(d)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(e)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(g)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(h)
@ -173,40 +173,40 @@ def test_delete_edge_remove_edge_recursive_steps(state):
f = state.create_node()
g = state.create_edge(f, e)
h = state.create_edge(b, 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
assert f is not None
assert g is not None
assert h is not None
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
assert f != None
assert g != None
assert h != None
n = state.delete_edge(g)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([d])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([h])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([d])
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([h, e])
s, t = state.read_edge(d)
@ -214,11 +214,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == b
l = state.read_outgoing(d)
assert l is not None
assert l != None
assert set(l) == set([e])
l = state.read_incoming(d)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(e)
@ -226,29 +226,29 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c
l = state.read_outgoing(e)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(e)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(g)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(g)
assert l is None
assert l == None
l = state.read_incoming(g)
assert l is None
assert l == None
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(h)
@ -256,30 +256,30 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c
n = state.delete_edge(e)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([d])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([h])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([d])
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([h])
s, t = state.read_edge(d)
@ -287,39 +287,39 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == b
l = state.read_outgoing(d)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(d)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(e)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(e)
assert l is None
assert l == None
l = state.read_incoming(e)
assert l is None
assert l == None
s, t = state.read_edge(g)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(g)
assert l is None
assert l == None
l = state.read_incoming(g)
assert l is None
assert l == None
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(h)
@ -327,55 +327,55 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c
n = state.delete_edge(d)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([h])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([h])
s, t = state.read_edge(d)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(d)
assert l is None
assert l == None
l = state.read_incoming(d)
assert l is None
assert l == None
s, t = state.read_edge(e)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(e)
assert l is None
assert l == None
l = state.read_incoming(e)
assert l is None
assert l == None
s, t = state.read_edge(g)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(g)
assert l == None
@ -384,11 +384,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert l == None
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(h)

146
state/test/test_delete_node.py
View file

@ -4,31 +4,31 @@ import pytest
@pytest.mark.usefixtures("state")
def test_delete_node_no_exists(state):
n = state.delete_node(-1)
assert n is None
assert n == None
@pytest.mark.usefixtures("state")
def test_delete_node_no_value(state):
a = state.create_node()
assert a is not None
assert a != None
n = state.delete_node(a)
assert n is None
assert n == None
@pytest.mark.usefixtures("state")
def test_delete_node_value(state):
a = state.create_nodevalue(1)
assert a is not None
assert a != None
d = state.read_value(a)
assert d == 1
n = state.delete_node(a)
assert n is None
assert n == None
d = state.read_value(a)
assert d is None
assert d == None
@pytest.mark.usefixtures("state")
@ -36,12 +36,12 @@ def test_delete_node_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
assert a != None
assert b != None
assert c != None
n = state.delete_node(c)
assert n is None
assert n == None
@pytest.mark.usefixtures("state")
@ -49,22 +49,22 @@ def test_delete_node_remove_edge_outgoing(state):
a = state.create_nodevalue(1)
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
assert a != None
assert b != None
assert c != None
n = state.delete_node(a)
assert n is None
assert n == None
d = state.read_value(a)
assert d is None
assert d == None
s, t = state.read_edge(c)
assert s is None
assert t is None
assert s == None
assert t == None
d = state.read_outgoing(b)
assert d is not None
assert d != None
assert set(d) == set([])
@ -73,22 +73,22 @@ def test_delete_node_remove_edge_incoming(state):
a = state.create_nodevalue(1)
b = state.create_node()
c = state.create_edge(b, a)
assert a is not None
assert b is not None
assert c is not None
assert a != None
assert b != None
assert c != None
n = state.delete_node(a)
assert n is None
assert n == None
d = state.read_value(a)
assert d is None
assert d == None
s, t = state.read_edge(c)
assert s is None
assert t is None
assert s == None
assert t == None
d = state.read_outgoing(b)
assert d is not None
assert d != None
assert set(d) == set([])
@ -99,32 +99,32 @@ def test_delete_node_remove_edge_both(state):
c = state.create_edge(a, b)
e = state.create_node()
f = state.create_edge(e, a)
assert a is not None
assert b is not None
assert c is not None
assert e is not None
assert f is not None
assert a != None
assert b != None
assert c != None
assert e != None
assert f != None
n = state.delete_node(a)
assert n is None
assert n == None
d = state.read_value(a)
assert d is None
assert d == None
s, t = state.read_edge(c)
assert s is None
assert t is None
assert s == None
assert t == None
d = state.read_incoming(b)
assert d is not None
assert d != None
assert set(d) == set([])
s, t = state.read_edge(f)
assert s is None
assert t is None
assert s == None
assert t == None
d = state.read_outgoing(e)
assert d is not None
assert d != None
assert set(d) == set([])
@ -134,27 +134,27 @@ def test_delete_node_remove_edge_recursive(state):
b = state.create_node()
c = state.create_edge(a, b)
d = state.create_edge(c, b)
assert a is not None
assert b is not None
assert c is not None
assert d is not None
assert a != None
assert b != None
assert c != None
assert d != None
n = state.delete_node(a)
assert n is None
assert n == None
d = state.read_value(a)
assert d is None
assert d == None
s, t = state.read_edge(c)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(d)
assert s is None
assert t is None
assert s == None
assert t == None
d = state.read_outgoing(b)
assert d is not None
assert d != None
assert set(d) == set([])
@ -168,58 +168,58 @@ def test_delete_node_remove_edge_recursive_deep(state):
f = state.create_node()
g = state.create_edge(f, e)
h = state.create_edge(b, 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
assert f is not None
assert g is not None
assert h is not None
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
assert f != None
assert g != None
assert h != None
n = state.delete_node(a)
assert n is None
assert n == None
l = state.read_outgoing(a)
assert l is None
assert l == None
l = state.read_incoming(a)
assert l is None
assert l == None
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([h])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([h])
s, t = state.read_edge(d)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(e)
assert s is None
assert t is None
assert s == None
assert t == None
s, t = state.read_edge(g)
assert s is None
assert t is None
assert s == None
assert t == None
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
s, t = state.read_edge(h)

52
state/test/test_read_dict.py
View file

@ -3,25 +3,25 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_dict_no_exists(state):
assert state.read_dict(-1, "abc") is None
assert state.read_dict(-1, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_not_found_node(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict(a, "abc") is None
assert state.read_dict(a, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_not_found_nodevalue(state):
a = state.create_nodevalue(1)
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict(a, "abc") is None
assert state.read_dict(a, "abc") == None
@pytest.mark.usefixtures("state")
@ -29,21 +29,21 @@ def test_read_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
assert a != None
assert b != None
assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict(c, "abc") is None
assert state.read_dict(c, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_no_primitive(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict(a, a) is None
assert state.read_dict(a, a) == None
@pytest.mark.usefixtures("state")
@ -53,11 +53,11 @@ def test_read_dict_node_simple(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_dict(a, "f")
assert l == b
@ -70,20 +70,20 @@ def test_read_dict_node_multi(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != 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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_dict(a, "f")
assert l == b
@ -91,4 +91,4 @@ def test_read_dict_node_multi(state):
l = state.read_dict(a, "k")
assert l == g
assert state.read_dict(a, "l") is None
assert state.read_dict(a, "l") == None

52
state/test/test_read_dict_edge.py
View file

@ -3,25 +3,25 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_dict_edge_no_exists(state):
assert state.read_dict_edge(-1, "abc") is None
assert state.read_dict_edge(-1, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_edge_not_found_node(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_edge(a, "abc") is None
assert state.read_dict_edge(a, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_edge_not_found_nodevalue(state):
a = state.create_nodevalue(1)
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_edge(a, "abc") is None
assert state.read_dict_edge(a, "abc") == None
@pytest.mark.usefixtures("state")
@ -29,21 +29,21 @@ def test_read_dict_edge_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
assert a != None
assert b != None
assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_edge(c, "abc") is None
assert state.read_dict_edge(c, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_edge_no_primitive(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_edge(a, a) is None
assert state.read_dict_edge(a, a) == None
@pytest.mark.usefixtures("state")
@ -53,11 +53,11 @@ def test_read_dict_edge_node_simple(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_dict_edge(a, "f")
assert l == d
@ -70,20 +70,20 @@ def test_read_dict_edge_node_multi(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != 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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_dict_edge(a, "f")
assert l == d
@ -91,4 +91,4 @@ def test_read_dict_edge_node_multi(state):
l = state.read_dict_edge(a, "k")
assert l == i
assert state.read_dict_edge(a, "l") is None
assert state.read_dict_edge(a, "l") == None

34
state/test/test_read_dict_keys.py
View file

@ -3,7 +3,7 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_dict_keys_no_exists(state):
assert state.read_dict_keys(100000) is None
assert state.read_dict_keys(100000) == None
@pytest.mark.usefixtures("state")
@ -13,14 +13,14 @@ def test_read_dict_keys_simple(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_dict_keys(a)
assert l is not None
assert l != None
assert set(l) == set([c])
@ -31,21 +31,21 @@ def test_read_dict_keys_multi(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != 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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_dict_keys(a)
assert l is not None
assert l != None
assert set(l) == set([c, h])

42
state/test/test_read_dict_node.py
View file

@ -3,7 +3,7 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_dict_node_no_exists(state):
assert state.read_dict_node(-1, "abc") is None
assert state.read_dict_node(-1, "abc") == None
@pytest.mark.usefixtures("state")
@ -11,21 +11,21 @@ def test_read_dict_node_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
assert a != None
assert b != None
assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_node(c, "abc") is None
assert state.read_dict_node(c, "abc") == None
@pytest.mark.usefixtures("state")
def test_read_dict_node_no_primitive(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
assert state.read_dict_node(a, a) is None
assert state.read_dict_node(a, a) == None
@pytest.mark.usefixtures("state")
@ -35,11 +35,11 @@ def test_read_dict_node_node_simple(state):
c = state.create_node()
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_dict_node(a, c)
assert l == b
@ -52,20 +52,20 @@ def test_read_dict_node_multi(state):
c = state.create_node()
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
g = state.create_node()
h = state.create_node()
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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_dict_node(a, c)
assert l == b

60
state/test/test_read_edge.py
View file

@ -4,28 +4,28 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_edge_node(state):
b = state.create_node()
assert b is not None
assert b != None
s, t = state.read_edge(b)
assert s is None
assert t is None
assert s == None
assert t == None
@pytest.mark.usefixtures("state")
def test_read_edge_no_exists(state):
s, t = state.read_edge(-1)
assert s is None
assert t is None
assert s == None
assert t == None
@pytest.mark.usefixtures("state")
def test_read_edge_nodevalue(state):
b = state.create_nodevalue(1)
assert b is not None
assert b != None
s, t = state.read_edge(b)
assert s is None
assert t is None
assert s == None
assert t == None
@pytest.mark.usefixtures("state")
@ -33,9 +33,9 @@ def test_read_edge_normal(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
assert a != None
assert b != None
assert c != None
s, t = state.read_edge(c)
assert s == a
@ -49,11 +49,11 @@ def test_read_edge_edge_to_edge(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(c, d)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
s, t = state.read_edge(c)
assert s == a
@ -74,10 +74,10 @@ def test_read_edge_edge_to_node(state):
b = state.create_node()
c = state.create_edge(a, b)
d = state.create_edge(c, b)
assert a is not None
assert b is not None
assert c is not None
assert d is not None
assert a != None
assert b != None
assert c != None
assert d != None
s, t = state.read_edge(c)
assert s == a
@ -94,10 +94,10 @@ def test_read_edge_node_to_edge(state):
b = state.create_node()
c = state.create_edge(a, b)
d = state.create_edge(b, c)
assert a is not None
assert b is not None
assert c is not None
assert d is not None
assert a != None
assert b != None
assert c != None
assert d != None
s, t = state.read_edge(c)
assert s == a
@ -113,9 +113,9 @@ def test_read_edge_node_to_nodevalue(state):
a = state.create_node()
b = state.create_nodevalue(1)
c = state.create_edge(a, b)
assert a is not None
assert b is not None
assert c is not None
assert a != None
assert b != None
assert c != None
s, t = state.read_edge(c)
assert s == a
@ -127,9 +127,9 @@ def test_read_edge_nodevalue_to_nodevalue(state):
a = state.create_nodevalue(1)
b = state.create_nodevalue(1)
c = state.create_edge(a, b)
assert a is not None
assert b is not None
assert c is not None
assert a != None
assert b != None
assert c != None
s, t = state.read_edge(c)
assert s == a

160
state/test/test_read_incoming.py
View file

@ -4,10 +4,10 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_incoming_node_none(state):
b = state.create_node()
assert b is not None
assert b != None
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -16,16 +16,16 @@ def test_read_incoming_node_one(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
assert a != None
assert b != None
assert c != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([c])
@ -36,18 +36,18 @@ def test_read_incoming_node_multi(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
@ -58,25 +58,25 @@ def test_read_incoming_node_multi_others_unaffected(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
f = state.create_node()
assert f is not None
assert f != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
@ -85,12 +85,12 @@ def test_read_incoming_edge_none(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
assert a != None
assert b != None
assert c != None
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([])
@ -101,22 +101,22 @@ def test_read_incoming_edge_one(state):
c = state.create_edge(a, b)
d = state.create_edge(c, a)
e = state.create_edge(a, 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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([e])
l = state.read_incoming(d)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(e)
assert l is not None
assert l != None
assert set(l) == set([])
@ -128,41 +128,41 @@ def test_read_incoming_edge_multi(state):
d = state.create_edge(a, c)
e = state.create_edge(b, c)
f = 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
assert f is not None
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
assert f != None
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([c])
l = state.read_incoming(c)
assert l is not None
assert l != None
assert set(l) == set([d, e, f])
l = state.read_incoming(d)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(e)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
@pytest.mark.usefixtures("state")
def test_read_incoming_nodevalue_none(state):
b = state.create_nodevalue(1)
assert b is not None
assert b != None
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -171,16 +171,16 @@ def test_read_incoming_nodevalue_one(state):
a = state.create_nodevalue(1)
b = state.create_node()
c = state.create_edge(b, a)
assert a is not None
assert b is not None
assert c is not None
assert a != None
assert b != None
assert c != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([c])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -191,18 +191,18 @@ def test_read_incoming_nodevalue_multi(state):
c = state.create_edge(b, a)
d = state.create_edge(b, a)
e = state.create_edge(b, a)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -213,50 +213,50 @@ def test_read_incoming_nodevalue_multi_others_unaffected(state):
c = state.create_edge(b, a)
d = state.create_edge(b, a)
e = state.create_edge(b, a)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
f = state.create_nodevalue(1)
assert f is not None
assert f != None
l = state.read_incoming(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_incoming(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_incoming(f)
assert l is not None
assert l != None
assert set(l) == set([])
@pytest.mark.usefixtures("state")
def test_read_incoming_node_deleted(state):
b = state.create_node()
assert b is not None
assert b != None
n = state.delete_node(b)
assert n is None
assert n == None
l = state.read_incoming(b)
assert l is None
assert l == None
@pytest.mark.usefixtures("state")
def test_read_incoming_nodevalue_deleted(state):
b = state.create_nodevalue(1)
assert b is not None
assert b != None
n = state.delete_node(b)
assert n is None
assert n == None
l = state.read_incoming(b)
assert l is None
assert l == None
@pytest.mark.usefixtures("state")
@ -264,12 +264,12 @@ def test_read_incoming_edge_deleted(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
assert a != None
assert b != None
assert c != None
n = state.delete_edge(c)
assert n is None
assert n == None
l = state.read_incoming(c)
assert l is None
assert l == None

154
state/test/test_read_outgoing.py
View file

@ -4,10 +4,10 @@ import pytest
@pytest.mark.usefixtures("state")
def test_read_outgoing_node_none(state):
b = state.create_node()
assert b is not None
assert b != None
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -16,16 +16,16 @@ def test_read_outgoing_node_one(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
assert a != None
assert b != None
assert c != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -36,18 +36,18 @@ def test_read_outgoing_node_multi(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -58,25 +58,25 @@ def test_read_outgoing_node_multi_others_unaffected(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
f = state.create_node()
assert f is not None
assert f != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
@ -85,12 +85,12 @@ def test_read_outgoing_edge_none(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
assert a != None
assert b != None
assert c != None
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([])
@ -100,17 +100,17 @@ def test_read_outgoing_edge_one(state):
b = state.create_node()
c = state.create_edge(a, b)
d = state.create_edge(c, a)
assert a is not None
assert b is not None
assert c is not None
assert d is not None
assert a != None
assert b != None
assert c != None
assert d != None
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([d])
l = state.read_outgoing(d)
assert l is not None
assert l != None
assert set(l) == set([])
@ -122,37 +122,37 @@ def test_read_outgoing_edge_multi(state):
d = state.create_edge(c, a)
e = state.create_edge(c, b)
f = state.create_edge(c, d)
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
assert f is not None
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
assert f != None
l = state.read_outgoing(c)
assert l is not None
assert l != None
assert set(l) == set([d, e, f])
l = state.read_outgoing(d)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(e)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
@pytest.mark.usefixtures("state")
def test_read_outgoing_nodevalue_none(state):
b = state.create_nodevalue(1)
assert b is not None
assert b != None
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -161,16 +161,16 @@ def test_read_outgoing_nodevalue_one(state):
a = state.create_nodevalue(1)
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
assert a != None
assert b != None
assert c != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -181,18 +181,18 @@ def test_read_outgoing_nodevalue_multi(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
@ -203,50 +203,50 @@ def test_read_outgoing_nodevalue_multi_others_unaffected(state):
c = state.create_edge(a, b)
d = state.create_edge(a, b)
e = state.create_edge(a, b)
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
f = state.create_nodevalue(1)
assert f is not None
assert f != None
l = state.read_outgoing(a)
assert l is not None
assert l != None
assert set(l) == set([c, d, e])
l = state.read_outgoing(b)
assert l is not None
assert l != None
assert set(l) == set([])
l = state.read_outgoing(f)
assert l is not None
assert l != None
assert set(l) == set([])
@pytest.mark.usefixtures("state")
def test_read_outgoing_node_deleted(state):
b = state.create_node()
assert b is not None
assert b != None
n = state.delete_node(b)
assert n is None
assert n == None
l = state.read_outgoing(b)
assert l is None
assert l == None
@pytest.mark.usefixtures("state")
def test_read_outgoing_nodevalue_deleted(state):
b = state.create_nodevalue(1)
assert b is not None
assert b != None
n = state.delete_node(b)
assert n is None
assert n == None
l = state.read_outgoing(b)
assert l is None
assert l == None
@pytest.mark.usefixtures("state")
@ -254,12 +254,12 @@ def test_read_outgoing_edge_deleted(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
assert a != None
assert b != None
assert c != None
n = state.delete_edge(c)
assert n is None
assert n == None
l = state.read_outgoing(c)
assert l is None
assert l == None

84
state/test/test_read_reverse_dict.py
View file

@ -4,13 +4,13 @@ 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
assert l == None
@pytest.mark.usefixtures("state")
def test_read_reverse_dict_not_found_node(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, "abc")
@ -20,7 +20,7 @@ def test_read_reverse_dict_not_found_node(state):
@pytest.mark.usefixtures("state")
def test_read_reverse_dict_not_found_nodevalue(state):
a = state.create_nodevalue(1)
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, "abc")
@ -32,9 +32,9 @@ 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
assert a != None
assert b != None
assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(c, "abc")
@ -44,7 +44,7 @@ def test_read_reverse_dict_not_found_edge(state):
@pytest.mark.usefixtures("state")
def test_read_reverse_dict_no_primitive(state):
a = state.create_node()
assert a is not None
assert a != None
# Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, a)
@ -58,11 +58,11 @@ def test_read_reverse_dict_node_simple(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_reverse_dict(b, "f")
assert set(l) == set([a])
@ -75,11 +75,11 @@ def test_read_reverse_dict_no_match(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
l = state.read_reverse_dict(b, "f")
assert l == []
@ -92,20 +92,20 @@ def test_read_reverse_dict_node_multi(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != 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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_reverse_dict(b, "f")
assert set(l) == set([a])
@ -124,20 +124,20 @@ def test_read_reverse_dict_node_multi_ambiguous(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != 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
assert g != None
assert h != None
assert i != None
assert j != None
l = state.read_reverse_dict(a, "f")
assert set(l) == set([b, g])
@ -150,16 +150,16 @@ def test_read_reverse_dict_node_uncertain(state):
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
assert a != None
assert b != None
assert c != None
assert d != None
assert e != None
h = state.create_nodevalue("g")
i = state.create_edge(d, h)
assert h is not None
assert i is not None
assert h != None
assert i != None
l = state.read_reverse_dict(b, "f")
assert set(l) == set([a])

24
state/test/test_read_value.py
View file

@ -5,8 +5,8 @@ import pytest
def test_read_value_different_id_simple(state):
id1 = state.create_nodevalue(1)
id2 = state.create_nodevalue(2)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
v1 = state.read_value(id1)
v2 = state.read_value(id2)
@ -19,7 +19,7 @@ def test_read_value_integer_ib_negative(state):
# Just within range
for i in range(-2 ** 63, -2 ** 63 + 10):
id1 = state.create_nodevalue(i)
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == i
@ -30,7 +30,7 @@ def test_read_value_integer_ib_zero(state):
# Nicely within range
for i in range(-10, 10):
id1 = state.create_nodevalue(i)
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == i
@ -41,7 +41,7 @@ def test_read_value_integer_ib_positive(state):
# Just within range
for i in range(2 ** 63 - 10, 2 ** 63):
id1 = state.create_nodevalue(i)
assert id1 is not None
assert id1 != None
v = state.read_value(id1)
assert v == i
@ -51,8 +51,8 @@ def test_read_value_integer_ib_positive(state):
def test_read_value_boolean(state):
id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(False)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
v1 = state.read_value(id1)
v2 = state.read_value(id2)
@ -64,8 +64,8 @@ def test_read_value_boolean(state):
def test_read_nodevalue_boolean_same(state):
id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(True)
assert id1 is not None
assert id2 is not None
assert id1 != None
assert id2 != None
v1 = state.read_value(id1)
v2 = state.read_value(id2)
@ -76,13 +76,13 @@ def test_read_nodevalue_boolean_same(state):
@pytest.mark.usefixtures("state")
def test_read_value_no_exist(state):
v1 = state.read_value(100000)
assert v1 is None
assert v1 == None
@pytest.mark.usefixtures("state")
def test_read_value_no_value(state):
id1 = state.create_node()
assert id1 is not None
assert id1 != None
v1 = state.read_value(id1)
assert v1 is None
assert v1 == None