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

51
framework/conformance.py
View file

@ -4,6 +4,8 @@ from state.base import State
from typing import Dict, Tuple, Set, Any, List
from pprint import pprint
import functools
class Conformance:
def __init__(self, state: State, model: UUID, type_model: UUID):
@ -21,8 +23,8 @@ class Conformance:
}
self.type_model_names = {
# map type model elements to their names to prevent iterating too much
self.bottom.read_outgoing_elements(self.type_model, e)[0]: e
for e in self.bottom.read_keys(self.type_model)
self.bottom.read_outgoing_elements(self.type_model, e)[0]
: e for e in self.bottom.read_keys(self.type_model)
}
self.sub_types: Dict[str, Set[str]] = {
k: set() for k in self.bottom.read_keys(self.type_model)
@ -192,8 +194,8 @@ class Conformance:
self.abstract_types.append(tm_name)
if lc or uc:
mult = (
lc if lc is not None else float("-inf"),
uc if uc is not None else float("inf")
lc if lc != None else float("-inf"),
uc if uc != None else float("inf")
)
self.multiplicities[tm_name] = mult
# multiplicities for associations
@ -201,21 +203,21 @@ class Conformance:
suc = self.read_attribute(tm_element, "source_upper_cardinality")
if slc or suc:
mult = (
slc if slc is not None else float("-inf"),
suc if suc is not None else float("inf")
slc if slc != None else float("-inf"),
suc if suc != None else float("inf")
)
self.source_multiplicities[tm_name] = mult
tlc = self.read_attribute(tm_element, "target_lower_cardinality")
tuc = self.read_attribute(tm_element, "target_upper_cardinality")
if tlc or tuc:
mult = (
tlc if tlc is not None else float("-inf"),
tuc if tuc is not None else float("inf")
tlc if tlc != None else float("-inf"),
tuc if tuc != None else float("inf")
)
self.target_multiplicities[tm_name] = mult
# optional for attribute links
opt = self.read_attribute(tm_element, "optional")
if opt is not None:
if opt != None:
self.source_multiplicities[tm_name] = (0 if opt else 1, 1)
self.target_multiplicities[tm_name] = (0, 1)
@ -245,7 +247,9 @@ class Conformance:
sub_tm = UUID(self.bottom.read_value(tm_element))
if not Conformance(self.state, sub_m, sub_tm).check_nominal():
raise RuntimeError(f"Incorrectly model reference: {m_name}")
except ValueError:
except ValueError as e:
import traceback
traceback.format_exc(e)
# no or too many morphism links found
raise RuntimeError(f"Incorrectly typed element: {m_name}")
return True
@ -259,7 +263,7 @@ class Conformance:
m_element, = self.bottom.read_outgoing_elements(self.model, m_name)
m_source = self.bottom.read_edge_source(m_element)
m_target = self.bottom.read_edge_target(m_element)
if m_source is None or m_target is None:
if m_source == None or m_target == None:
# element is not a link
continue
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
@ -367,7 +371,7 @@ class Conformance:
if tm_name != "GlobalConstraint":
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
code = self.read_attribute(tm_element, "constraint")
if code is not None:
if code != None:
morphisms = self.bottom.read_incoming_elements(tm_element, "Morphism")
morphisms = [m for m in morphisms if m in self.model_names]
for m_element in morphisms:
@ -379,7 +383,7 @@ class Conformance:
if tm_name == "GlobalConstraint":
tm_element, = self.bottom.read_outgoing_elements(self.type_model, tm_name)
code = self.read_attribute(tm_element, "constraint")
if code is not None:
if code != None:
if not self.evaluate_constraint(code, model=self.model):
raise RuntimeError(f"Global constraint {tm_name} not satisfied.")
return True
@ -460,14 +464,17 @@ class Conformance:
ref_element, = self.bottom.read_outgoing_elements(self.scd_model, "ModelRef")
# matching
for m_element, m_name in self.model_names.items():
is_edge = self.bottom.read_edge_source(m_element) is not None
is_edge = self.bottom.read_edge_source(m_element) != None
print('element:', m_element, 'name:', m_name, 'is_edge', is_edge)
for type_name, structure in self.structures.items():
tm_element, = self.bottom.read_outgoing_elements(self.type_model, type_name)
type_is_edge = self.bottom.read_edge_source(tm_element) is not None
type_is_edge = self.bottom.read_edge_source(tm_element) != None
if is_edge == type_is_edge:
print(' type_name:', type_name, 'type_is_edge:', type_is_edge, "structure:", structure)
mismatch = False
matched = 0
for name, optional, attr_type in structure:
print(' name:', name, "optional:", optional, "attr_type:", attr_type)
try:
attr, = self.bottom.read_outgoing_elements(self.model, f"{m_name}.{name}")
attr_tm, = self.bottom.read_outgoing_elements(self.type_model, attr_type)
@ -485,26 +492,34 @@ class Conformance:
else:
# eval constraints
code = self.read_attribute(attr_tm, "constraint")
if code is not None:
if code != None:
attr_conforms = self.evaluate_constraint(code, element=attr)
if attr_conforms:
matched += 1
except ValueError:
print(" attr_conforms -> matched:", matched)
except ValueError as e:
# attr not found or failed parsing UUID
if optional:
print(" skipping:", e)
continue
else:
# did not match mandatory attribute
print(" breaking:", e)
mismatch = True
break
print(' matched:', matched, 'len(structure):', len(structure))
# if matched == len(structure):
if not mismatch:
print(' add to candidates:', m_name, type_name)
self.candidates.setdefault(m_name, set()).add(type_name)
# filter out candidates for links based on source and target types
for m_element, m_name in self.model_names.items():
is_edge = self.bottom.read_edge_source(m_element) is not None
is_edge = self.bottom.read_edge_source(m_element) != None
if is_edge and m_name in self.candidates:
m_source = self.bottom.read_edge_source(m_element)
m_target = self.bottom.read_edge_target(m_element)
print(self.candidates)
source_candidates = self.candidates[self.model_names[m_source]]
target_candidates = self.candidates[self.model_names[m_target]]
remove = set()

6
framework/interactive_prompt.py
View file

@ -35,11 +35,11 @@ def main():
man = Manager(state)
while True:
if man.current_model is not None and man.current_context is None:
if man.current_model != None and man.current_context == None:
# we have selected a model, so we display typing questions
answer = prompt(questions.MODEL_SELECTED)
ctx = man
elif man.current_model is not None and man.current_context is not None:
elif man.current_model != None and man.current_context != None:
# we have selected both a model and a context, so we display available services
qs = generate_context_question(type(man.current_context), man.get_services())
answer = prompt(qs)
@ -79,7 +79,7 @@ def main():
args = {k: types[k](v) if len(v) > 0 else None for k, v in args.items()}
try:
output = method(**args)
if output is not None:
if output != None:
try:
if isinstance(output, str):
raise TypeError

24
framework/manager.py
View file

@ -1,5 +1,6 @@
from state.base import State
from bootstrap.scd import bootstrap_scd
from bootstrap.pn import bootstrap_pn
from services import implemented as services
from framework.conformance import Conformance
from uuid import UUID
@ -11,6 +12,7 @@ class Manager:
self.current_context = None
self.state = state
bootstrap_scd(state)
# bootstrap_pn(state, "PN")
scd_node = self.state.read_dict(self.state.read_root(), "SCD")
for key_node in self.state.read_dict_keys(self.state.read_root()):
model_node = self.state.read_dict_node(self.state.read_root(), key_node)
@ -39,7 +41,7 @@ class Manager:
"""
root = self.state.read_root()
type_model_node = self.state.read_dict(root, type_model_name)
if type_model_node is None:
if type_model_node == None:
raise RuntimeError(f"No type model with name {type_model_name} found.")
else:
# check if model is a linguistic type model
@ -71,7 +73,7 @@ class Manager:
"""
root = self.state.read_root()
model_node = self.state.read_dict(root, name)
if model_node is None:
if model_node == None:
raise RuntimeError(f"No model with name {name} found.")
model_root = UUID(self.state.read_value(model_node))
self.current_model = (name, model_root)
@ -94,7 +96,7 @@ class Manager:
Names of the model's types
"""
root = self.state.read_root()
if self.current_model is None:
if self.current_model == None:
raise RuntimeError(f"No model currently selected.")
name, model = self.current_model
model_id = self.state.read_dict(root, name)
@ -142,9 +144,9 @@ class Manager:
Returns:
Functions exposed by the current context's implementation
"""
if self.current_model is None:
if self.current_model == None:
raise RuntimeError(f"No model currently selected.")
if self.current_context is None:
if self.current_context == None:
raise RuntimeError(f"No context currently selected.")
yield from [
getattr(self.current_context, func)
@ -171,14 +173,16 @@ class Manager:
"""
root = self.state.read_root()
type_model_node = self.state.read_dict(root, type_model_name)
if type_model_node is None:
if type_model_node == None:
raise RuntimeError(f"No type model with name {type_model_name} found.")
model_node = self.state.read_dict(root, model_name)
if model_node is None:
if model_node == None:
raise RuntimeError(f"No model with name {model_node} found.")
types = self.state.read_outgoing(model_node)
types = [self.state.read_edge(e)[1] for e in types]
if type_model_node not in types:
# if type_model_node not in types:
if True:
print("checking structural conformance")
conf = Conformance(self.state,
UUID(self.state.read_value(model_node)),
UUID(self.state.read_value(type_model_node))).check_structural(log=True)
@ -186,6 +190,7 @@ class Manager:
self.state.create_edge(model_node, type_model_node)
return conf
else:
print("checking nominal conformance")
return Conformance(self.state,
UUID(self.state.read_value(model_node)),
UUID(self.state.read_value(type_model_node))).check_nominal(log=True)
@ -206,6 +211,9 @@ class Manager:
with open("state.p", "rb") as file:
self.state = pickle.load(file)
def to_graphviz(self):
self.state.dump("state.dot")
if __name__ == '__main__':
from state.devstate import DevState

1
framework/prompt_questions.py
View file

@ -28,6 +28,7 @@ MODEL_MGMT = [
Separator(),
'load state',
'dump state',
'to graphviz',
Separator(),
'exit'
],

22
services/bottom/V0.py
View file

@ -21,7 +21,7 @@ class Bottom:
Returns:
UUID of the node.
"""
if value is None:
if value == None:
return self.state.create_node()
else:
return self.state.create_nodevalue(value)
@ -38,7 +38,7 @@ class Bottom:
Returns:
UUID of the edge.
"""
if label is None:
if label == None:
return self.state.create_edge(source, target)
else:
return self.state.create_dict(source, label, target)
@ -66,7 +66,7 @@ class Bottom:
UUID of source element of the edge
"""
result = self.state.read_edge(edge)
return result[0] if result is not None else result
return result[0] if result != None else result
def read_edge_target(self, edge: UUID) -> UUID:
"""
@ -79,7 +79,7 @@ class Bottom:
UUID of target element of the edge
"""
result = self.state.read_edge(edge)
return result[1] if result is not None else result
return result[1] if result != None else result
def read_incoming_edges(self, target: UUID, label=None) -> List[UUID]:
"""
@ -102,9 +102,9 @@ class Bottom:
return None
edges = self.state.read_incoming(target)
if edges is None:
if edges == None:
return []
if label is not None:
if label != None:
edges = [e for e in edges if read_label(e) == label]
return edges
@ -129,9 +129,9 @@ class Bottom:
return None
edges = self.state.read_outgoing(source)
if edges is None:
if edges == None:
return []
if label is not None:
if label != None:
edges = [e for e in edges if read_label(e) == label]
return edges
@ -148,7 +148,7 @@ class Bottom:
List of UUIDs of elements connected via incoming edges
"""
edges = self.read_incoming_edges(target, label)
if edges is None or len(edges) == 0:
if edges == None or len(edges) == 0:
return []
else:
return [self.read_edge_source(e) for e in edges]
@ -166,7 +166,7 @@ class Bottom:
List of UUIDs of elements connected via outgoing edges
"""
edges = self.read_outgoing_edges(source, label)
if edges is None or len(edges) == 0:
if edges == None or len(edges) == 0:
return []
else:
return [self.read_edge_target(e) for e in edges]
@ -196,7 +196,7 @@ class Bottom:
Nothing
"""
src, tgt = self.state.read_edge(element)
if src is None and tgt is None:
if src == None and tgt == None:
# node
self.state.delete_node(element)
else:

2
services/bottom/V1.py
View file

@ -25,7 +25,7 @@ class Bottom:
Returns:
Nothing
"""
if value is None:
if value == None:
n = self.bottom.create_node()
else:
n = self.bottom.create_node(value)

6
services/point/cartesian.py
View file

@ -28,7 +28,7 @@ class PointCartesian:
Returns:
Nothing.
"""
if self.point is None:
if self.point == None:
self.point = (x, y)
else:
raise RuntimeError("A PointCartesian model can contain at most 1 point.")
@ -40,7 +40,7 @@ class PointCartesian:
Returns:
Textual representation of the point data.
"""
if self.point is None:
if self.point == None:
raise RuntimeError("No point found in model.")
else:
return f"(X = {self.point[0]}, Y = {self.point[1]})"
@ -65,7 +65,7 @@ class PointCartesian:
Returns:
Nothing.
"""
if self.point is not None:
if self.point != None:
self.point = (self.point[0] + delta_x, self.point[1] + delta_y)
else:
raise RuntimeError("No point found in model.")

6
services/point/polar.py
View file

@ -30,7 +30,7 @@ class PointPolar:
Returns:
Nothing.
"""
if self.point is None:
if self.point == None:
self.point = (r, theta)
else:
raise RuntimeError("A PointPolar model can contain at most 1 point.")
@ -42,7 +42,7 @@ class PointPolar:
Returns:
Textual representation of the point data.
"""
if self.point is None:
if self.point == None:
raise RuntimeError("No point found in model.")
else:
return f"(r = {self.point[0]}, \u03B8 = {self.point[1]})"
@ -67,7 +67,7 @@ class PointPolar:
Returns:
Nothing.
"""
if self.point is not None:
if self.point != None:
self.point = (self.point[0] + delta_r, self.point[1] + delta_theta)
else:
raise RuntimeError("No point found in model.")

14
services/scd.py
View file

@ -55,7 +55,7 @@ class SCD:
self.bottom.create_edge(self.model, class_node, name) # attach to model
scd_node, = self.bottom.read_outgoing_elements(self.scd_model, "Class") # retrieve type
self.bottom.create_edge(class_node, scd_node, "Morphism") # create morphism link
if abstract is not None:
if abstract != None:
# operations similar to set_cardinality function defined above
abstract_model = self.bottom.create_node()
Boolean(abstract_model, self.bottom.state).create(abstract)
@ -67,9 +67,9 @@ class SCD:
scd_link, = self.bottom.read_outgoing_elements(self.scd_model, "Class_abstract")
self.bottom.create_edge(abstract_node, scd_node, "Morphism")
self.bottom.create_edge(abstract_link, scd_link, "Morphism")
if min_c is not None:
if min_c != None:
set_cardinality("lower", min_c)
if max_c is not None:
if max_c != None:
set_cardinality("upper", max_c)
def create_association(self, name: str, source: str, target: str,
@ -118,13 +118,13 @@ class SCD:
self.bottom.create_edge(self.model, assoc_edge, name) # attach to model
scd_node, = self.bottom.read_outgoing_elements(self.scd_model, "Association") # retrieve type
self.bottom.create_edge(assoc_edge, scd_node, "Morphism") # create morphism link
if src_min_c is not None:
if src_min_c != None:
set_cardinality("source_lower", src_min_c)
if src_max_c is not None:
if src_max_c != None:
set_cardinality("source_upper", src_max_c)
if tgt_min_c is not None:
if tgt_min_c != None:
set_cardinality("target_lower", tgt_min_c)
if tgt_max_c is not None:
if tgt_max_c != None:
set_cardinality("target_upper", tgt_max_c)
def create_global_constraint(self, name: str):

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

6
transformation/ramify.py
View file

@ -116,7 +116,7 @@ def ramify(state: State, model: UUID) -> UUID:
# - min-card: 0
# - max-card: same as original
upper_card = find_cardinality(class_node, class_upper_card_node)
print('creating class', class_name, "with upper card", upper_card)
print('creating class', class_name, "with card 0 ..", upper_card)
ramified_scd.create_class(class_name, abstract=None, max_c=upper_card)
for (attr_name, attr_type) in get_attributes(class_node):
@ -137,9 +137,7 @@ def ramify(state: State, model: UUID) -> UUID:
src = scd.get_class_name(bottom.read_edge_source(assoc_node))
tgt = scd.get_class_name(bottom.read_edge_target(assoc_node))
print('creating assoc', src, "->", tgt, ", name =", assoc_name, ", src card = 0 ..", src_upper_card, "and tgt card = 0 ..", tgt_upper_card)
ramified_scd.create_association(assoc_name,
src,
tgt,
ramified_scd.create_association(assoc_name, src, tgt,
src_max_c=src_upper_card,
tgt_max_c=tgt_upper_card)