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

6
framework/interactive_prompt.py
View file

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

24
framework/manager.py
View file

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

1
framework/prompt_questions.py
View file

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

22
services/bottom/V0.py
View file

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

2
services/bottom/V1.py
View file

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

6
services/point/cartesian.py
View file

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

6
services/point/polar.py
View file

@ -30,7 +30,7 @@ class PointPolar:
Returns: Returns:
Nothing. Nothing.
""" """
if self.point is None: if self.point == None:
self.point = (r, theta) self.point = (r, theta)
else: else:
raise RuntimeError("A PointPolar model can contain at most 1 point.") raise RuntimeError("A PointPolar model can contain at most 1 point.")
@ -42,7 +42,7 @@ class PointPolar:
Returns: Returns:
Textual representation of the point data. Textual representation of the point data.
""" """
if self.point is None: if self.point == None:
raise RuntimeError("No point found in model.") raise RuntimeError("No point found in model.")
else: else:
return f"(r = {self.point[0]}, \u03B8 = {self.point[1]})" return f"(r = {self.point[0]}, \u03B8 = {self.point[1]})"
@ -67,7 +67,7 @@ class PointPolar:
Returns: Returns:
Nothing. Nothing.
""" """
if self.point is not None: if self.point != None:
self.point = (self.point[0] + delta_r, self.point[1] + delta_theta) self.point = (self.point[0] + delta_r, self.point[1] + delta_theta)
else: else:
raise RuntimeError("No point found in model.") 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 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 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 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 # operations similar to set_cardinality function defined above
abstract_model = self.bottom.create_node() abstract_model = self.bottom.create_node()
Boolean(abstract_model, self.bottom.state).create(abstract) 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") 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_node, scd_node, "Morphism")
self.bottom.create_edge(abstract_link, scd_link, "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) set_cardinality("lower", min_c)
if max_c is not None: if max_c != None:
set_cardinality("upper", max_c) set_cardinality("upper", max_c)
def create_association(self, name: str, source: str, target: str, 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 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 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 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) 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) 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) 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) set_cardinality("target_upper", tgt_max_c)
def create_global_constraint(self, name: str): 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("\"a_%s\" -> \"a_%s\";\n" % (i.int, e[1].int))
f.write("}") f.write("}")
if png_path is not None: if png_path != None:
# generate png from dot-file # generate png from dot-file
bashCommand = f"dot -Tpng {path} -o {png_path}" bashCommand = f"dot -Tpng {path} -o {png_path}"
import subprocess import subprocess

48
state/neo4jstate.py
View file

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

6
state/pystate.py
View file

@ -67,7 +67,7 @@ class PyState(State):
else: else:
n = self.create_nodevalue(value) n = self.create_nodevalue(value)
e = self.create_edge(source, target) 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) e2 = self.create_edge(e, n)
self.cache.setdefault(source, {})[value] = e self.cache.setdefault(source, {})[value] = e
self.cache_node.setdefault(source, {})[n] = 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]: def read_dict(self, elem: Element, value: Any) -> Optional[Element]:
e = self.read_dict_edge(elem, value) e = self.read_dict_edge(elem, value)
if e is None: if e == None:
return None return None
else: else:
return self.edges[e][1] return self.edges[e][1]
@ -142,7 +142,7 @@ class PyState(State):
def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]: def read_dict_node(self, elem: Element, value_node: Node) -> Optional[Element]:
e = self.read_dict_node_edge(elem, value_node) e = self.read_dict_node_edge(elem, value_node)
if e is None: if e == None:
return None return None
else: else:
self.cache_node.setdefault(elem, {})[value_node] = e 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): def test_create_dict_simple(state):
id1 = state.create_node() id1 = state.create_node()
id2 = state.create_node() id2 = state.create_node()
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
n = state.create_dict(id1, "abc", id2) n = state.create_dict(id1, "abc", id2)
assert n is None assert n == None
v = state.read_dict(id1, "abc") v = state.read_dict(id1, "abc")
assert v == id2 assert v == id2
@ -19,23 +19,23 @@ def test_create_dict_simple(state):
def test_create_dict_no_source(state): def test_create_dict_no_source(state):
id1 = 100000 id1 = 100000
id2 = state.create_node() id2 = state.create_node()
assert id2 is not None assert id2 != None
n = state.create_dict(id1, "abc", id2) n = state.create_dict(id1, "abc", id2)
assert n is None assert n == None
v = state.read_dict(id1, "abc") v = state.read_dict(id1, "abc")
assert v is None assert v == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_dict_no_target(state): def test_create_dict_no_target(state):
id2 = 100000 id2 = 100000
id1 = state.create_node() id1 = state.create_node()
assert id1 is not None assert id1 != None
n = state.create_dict(id1, "abc", id2) n = state.create_dict(id1, "abc", id2)
assert n is None assert n == None
v = state.read_dict(id1, "abc") 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): def test_create_edge_invalid_source(state):
a = -1 a = -1
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_invalid_target(state): def test_create_edge_invalid_target(state):
b = -1 b = -1
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -26,32 +26,32 @@ def test_create_edge_invalid_both(state):
a = -1 a = -1
b = -1 b = -1
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_node_to_node(state): def test_create_edge_node_to_node(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge = state.create_edge(a, b) edge = state.create_edge(a, b)
assert edge is not None assert edge != None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_multiple(state): def test_create_edge_multiple(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge1 = state.create_edge(a, b) edge1 = state.create_edge(a, b)
assert edge1 is not None assert edge1 != None
edge2 = state.create_edge(a, b) edge2 = state.create_edge(a, b)
assert edge2 is not None assert edge2 != None
assert edge1 != edge2 assert edge1 != edge2
@ -61,12 +61,12 @@ def test_create_edge_many(state):
v = set() v = set()
for i in range(1000): for i in range(1000):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge = state.create_edge(a, b) edge = state.create_edge(a, b)
assert edge is not None assert edge != None
v.add(edge) v.add(edge)
assert len(v) == 1000 assert len(v) == 1000
@ -75,15 +75,15 @@ def test_create_edge_many(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_edge_to_node(state): def test_create_edge_edge_to_node(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge1 = state.create_edge(a, b) edge1 = state.create_edge(a, b)
assert edge1 is not None assert edge1 != None
edge2 = state.create_edge(edge1, b) edge2 = state.create_edge(edge1, b)
assert edge2 is not None assert edge2 != None
assert edge1 != edge2 assert edge1 != edge2
@ -91,15 +91,15 @@ def test_create_edge_edge_to_node(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_node_to_edge(state): def test_create_edge_node_to_edge(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge1 = state.create_edge(a, b) edge1 = state.create_edge(a, b)
assert edge1 is not None assert edge1 != None
edge2 = state.create_edge(a, edge1) edge2 = state.create_edge(a, edge1)
assert edge2 is not None assert edge2 != None
assert edge1 != edge2 assert edge1 != edge2
@ -107,38 +107,38 @@ def test_create_edge_node_to_edge(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_edge_to_edge(state): def test_create_edge_edge_to_edge(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
edge1 = state.create_edge(a, b) edge1 = state.create_edge(a, b)
assert edge1 is not None assert edge1 != None
edge2 = state.create_edge(a, b) edge2 = state.create_edge(a, b)
assert edge2 is not None assert edge2 != None
assert edge1 != edge2 assert edge1 != edge2
edge3 = state.create_edge(edge1, edge2) edge3 = state.create_edge(edge1, edge2)
assert edge3 is not None assert edge3 != None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_loop_node(state): def test_create_edge_loop_node(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
edge = state.create_edge(a, a) edge = state.create_edge(a, a)
assert edge is not None assert edge != None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_edge_loop_edge(state): def test_create_edge_loop_edge(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
edge1 = state.create_edge(a, a) edge1 = state.create_edge(a, a)
assert edge1 is not None assert edge1 != None
edge2 = state.create_edge(edge1, edge1) 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") @pytest.mark.usefixtures("state")
def test_create_node_different_id_simple(state): def test_create_node_different_id_simple(state):
id1 = state.create_node() id1 = state.create_node()
assert id1 is not None assert id1 != None
id2 = state.create_node() id2 = state.create_node()
assert id2 is not None assert id2 != None
assert id1 != id2 assert id1 != id2
@ -16,7 +16,7 @@ def test_create_node_different_id_long(state):
results = set() results = set()
for i in range(1000): for i in range(1000):
v = state.create_node() v = state.create_node()
assert v is not None assert v != None
results.add(v) results.add(v)
assert len(results) == 1000 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) id1 = state.create_nodevalue(1)
id2 = state.create_nodevalue(1) id2 = state.create_nodevalue(1)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
assert id1 != id2 assert id1 != id2
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_read(state): def test_create_nodevalue_read(state):
id1 = state.create_nodevalue(1) id1 = state.create_nodevalue(1)
assert id1 is not None assert id1 != None
val = state.read_value(id1) val = state.read_value(id1)
assert val == 1 assert val == 1
@ -26,7 +26,7 @@ def test_create_nodevalue_integer_ib_zero(state):
size = 0 size = 0
for i in range(-10, 10): for i in range(-10, 10):
id1 = state.create_nodevalue(i) id1 = state.create_nodevalue(i)
assert id1 is not None assert id1 != None
size += 1 size += 1
v.add(id1) v.add(id1)
assert len(v) == size assert len(v) == size
@ -37,8 +37,8 @@ def test_create_nodevalue_boolean(state):
id1 = state.create_nodevalue(True) id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(False) id2 = state.create_nodevalue(False)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
assert id1 != id2 assert id1 != id2
@ -47,15 +47,15 @@ def test_create_nodevalue_boolean_same(state):
id1 = state.create_nodevalue(True) id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(True) id2 = state.create_nodevalue(True)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
assert id1 != id2 assert id1 != id2
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_float_keeps_type(state): def test_create_nodevalue_float_keeps_type(state):
id1 = state.create_nodevalue(0.0) id1 = state.create_nodevalue(0.0)
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == float assert type(v) == float
@ -65,7 +65,7 @@ def test_create_nodevalue_float_keeps_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_string_empty(state): def test_create_nodevalue_string_empty(state):
id1 = state.create_nodevalue("") id1 = state.create_nodevalue("")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
@ -75,7 +75,7 @@ def test_create_nodevalue_string_empty(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_string_normal(state): def test_create_nodevalue_string_normal(state):
id1 = state.create_nodevalue("ABC") id1 = state.create_nodevalue("ABC")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
@ -85,28 +85,28 @@ def test_create_nodevalue_string_normal(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_string_not_parsed(state): def test_create_nodevalue_string_not_parsed(state):
id1 = state.create_nodevalue("1") id1 = state.create_nodevalue("1")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
assert v == "1" assert v == "1"
id1 = state.create_nodevalue("1.0") id1 = state.create_nodevalue("1.0")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
assert v == "1.0" assert v == "1.0"
id1 = state.create_nodevalue("-1.0") id1 = state.create_nodevalue("-1.0")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
assert v == "-1.0" assert v == "-1.0"
id1 = state.create_nodevalue("True") id1 = state.create_nodevalue("True")
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert type(v) == str assert type(v) == str
@ -119,13 +119,13 @@ def test_create_nodevalue_junk(state):
pass pass
n = state.create_nodevalue(Unknown()) n = state.create_nodevalue(Unknown())
assert n is None assert n == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_type_type(state): def test_create_nodevalue_type_type(state):
id1 = state.create_nodevalue(("Type",)) id1 = state.create_nodevalue(("Type",))
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == ("Type",) assert v == ("Type",)
@ -134,7 +134,7 @@ def test_create_nodevalue_type_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_integer_type(state): def test_create_nodevalue_integer_type(state):
id1 = state.create_nodevalue(("Integer",)) id1 = state.create_nodevalue(("Integer",))
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == ("Integer",) assert v == ("Integer",)
@ -143,7 +143,7 @@ def test_create_nodevalue_integer_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_float_type(state): def test_create_nodevalue_float_type(state):
id1 = state.create_nodevalue(("Float",)) id1 = state.create_nodevalue(("Float",))
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == ("Float",) assert v == ("Float",)
@ -152,7 +152,7 @@ def test_create_nodevalue_float_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_boolean_type(state): def test_create_nodevalue_boolean_type(state):
id1 = state.create_nodevalue(("Boolean",)) id1 = state.create_nodevalue(("Boolean",))
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == ("Boolean",) assert v == ("Boolean",)
@ -161,7 +161,7 @@ def test_create_nodevalue_boolean_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_string_type(state): def test_create_nodevalue_string_type(state):
id1 = state.create_nodevalue(("String",)) id1 = state.create_nodevalue(("String",))
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == ("String",) assert v == ("String",)
@ -170,4 +170,4 @@ def test_create_nodevalue_string_type(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_create_nodevalue_invalid_type(state): def test_create_nodevalue_invalid_type(state):
id1 = state.create_nodevalue(("Class",)) 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") @pytest.mark.usefixtures("state")
def test_delete_edge_no_exists(state): def test_delete_edge_no_exists(state):
e = state.delete_edge(1) e = state.delete_edge(1)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_delete_edge_node(state): def test_delete_edge_node(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
e = state.delete_edge(a) e = state.delete_edge(a)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_delete_edge_nodevalue(state): def test_delete_edge_nodevalue(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
assert a is not None assert a != None
e = state.delete_edge(a) e = state.delete_edge(a)
assert e is None assert e == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -30,27 +30,27 @@ def test_delete_edge_normal(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_edge(c) n = state.delete_edge(c)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -60,35 +60,35 @@ def test_delete_edge_remove_recursive(state):
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(c, b) d = state.create_edge(c, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
n = state.delete_edge(c) n = state.delete_edge(c)
assert n is None assert n == None
l = state.read_value(a) l = state.read_value(a)
assert l == 1 assert l == 1
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(c) s, t = state.read_edge(c)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(d) s, t = state.read_edge(d)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -102,60 +102,60 @@ def test_delete_edge_remove_edge_recursive_deep(state):
f = state.create_node() f = state.create_node()
g = state.create_edge(f, e) g = state.create_edge(f, e)
h = state.create_edge(b, c) h = state.create_edge(b, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
assert f is not None assert f != None
assert g is not None assert g != None
assert h is not None assert h != None
n = state.delete_edge(d) n = state.delete_edge(d)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
s, t = state.read_edge(d) s, t = state.read_edge(d)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(e) s, t = state.read_edge(e)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(g) s, t = state.read_edge(g)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(h) s, t = state.read_edge(h)
@ -173,40 +173,40 @@ def test_delete_edge_remove_edge_recursive_steps(state):
f = state.create_node() f = state.create_node()
g = state.create_edge(f, e) g = state.create_edge(f, e)
h = state.create_edge(b, c) h = state.create_edge(b, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
assert f is not None assert f != None
assert g is not None assert g != None
assert h is not None assert h != None
n = state.delete_edge(g) n = state.delete_edge(g)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([d]) assert set(l) == set([d])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([d]) assert set(l) == set([d])
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([h, e]) assert set(l) == set([h, e])
s, t = state.read_edge(d) s, t = state.read_edge(d)
@ -214,11 +214,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == b assert t == b
l = state.read_outgoing(d) l = state.read_outgoing(d)
assert l is not None assert l != None
assert set(l) == set([e]) assert set(l) == set([e])
l = state.read_incoming(d) l = state.read_incoming(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(e) s, t = state.read_edge(e)
@ -226,29 +226,29 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c assert t == c
l = state.read_outgoing(e) l = state.read_outgoing(e)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(e) l = state.read_incoming(e)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(g) s, t = state.read_edge(g)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(g) l = state.read_outgoing(g)
assert l is None assert l == None
l = state.read_incoming(g) l = state.read_incoming(g)
assert l is None assert l == None
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(h) s, t = state.read_edge(h)
@ -256,30 +256,30 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c assert t == c
n = state.delete_edge(e) n = state.delete_edge(e)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([d]) assert set(l) == set([d])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([d]) assert set(l) == set([d])
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
s, t = state.read_edge(d) s, t = state.read_edge(d)
@ -287,39 +287,39 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == b assert t == b
l = state.read_outgoing(d) l = state.read_outgoing(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(d) l = state.read_incoming(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(e) s, t = state.read_edge(e)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(e) l = state.read_outgoing(e)
assert l is None assert l == None
l = state.read_incoming(e) l = state.read_incoming(e)
assert l is None assert l == None
s, t = state.read_edge(g) s, t = state.read_edge(g)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(g) l = state.read_outgoing(g)
assert l is None assert l == None
l = state.read_incoming(g) l = state.read_incoming(g)
assert l is None assert l == None
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(h) s, t = state.read_edge(h)
@ -327,55 +327,55 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert t == c assert t == c
n = state.delete_edge(d) n = state.delete_edge(d)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
s, t = state.read_edge(d) s, t = state.read_edge(d)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(d) l = state.read_outgoing(d)
assert l is None assert l == None
l = state.read_incoming(d) l = state.read_incoming(d)
assert l is None assert l == None
s, t = state.read_edge(e) s, t = state.read_edge(e)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(e) l = state.read_outgoing(e)
assert l is None assert l == None
l = state.read_incoming(e) l = state.read_incoming(e)
assert l is None assert l == None
s, t = state.read_edge(g) s, t = state.read_edge(g)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(g) l = state.read_outgoing(g)
assert l == None assert l == None
@ -384,11 +384,11 @@ def test_delete_edge_remove_edge_recursive_steps(state):
assert l == None assert l == None
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(h) 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") @pytest.mark.usefixtures("state")
def test_delete_node_no_exists(state): def test_delete_node_no_exists(state):
n = state.delete_node(-1) n = state.delete_node(-1)
assert n is None assert n == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_delete_node_no_value(state): def test_delete_node_no_value(state):
a = state.create_node() a = state.create_node()
assert a is not None assert a != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_delete_node_value(state): def test_delete_node_value(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
assert a is not None assert a != None
d = state.read_value(a) d = state.read_value(a)
assert d == 1 assert d == 1
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
d = state.read_value(a) d = state.read_value(a)
assert d is None assert d == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -36,12 +36,12 @@ def test_delete_node_edge(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_node(c) n = state.delete_node(c)
assert n is None assert n == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -49,22 +49,22 @@ def test_delete_node_remove_edge_outgoing(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
d = state.read_value(a) d = state.read_value(a)
assert d is None assert d == None
s, t = state.read_edge(c) s, t = state.read_edge(c)
assert s is None assert s == None
assert t is None assert t == None
d = state.read_outgoing(b) d = state.read_outgoing(b)
assert d is not None assert d != None
assert set(d) == set([]) assert set(d) == set([])
@ -73,22 +73,22 @@ def test_delete_node_remove_edge_incoming(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
b = state.create_node() b = state.create_node()
c = state.create_edge(b, a) c = state.create_edge(b, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
d = state.read_value(a) d = state.read_value(a)
assert d is None assert d == None
s, t = state.read_edge(c) s, t = state.read_edge(c)
assert s is None assert s == None
assert t is None assert t == None
d = state.read_outgoing(b) d = state.read_outgoing(b)
assert d is not None assert d != None
assert set(d) == set([]) assert set(d) == set([])
@ -99,32 +99,32 @@ def test_delete_node_remove_edge_both(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
e = state.create_node() e = state.create_node()
f = state.create_edge(e, a) f = state.create_edge(e, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert e is not None assert e != None
assert f is not None assert f != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
d = state.read_value(a) d = state.read_value(a)
assert d is None assert d == None
s, t = state.read_edge(c) s, t = state.read_edge(c)
assert s is None assert s == None
assert t is None assert t == None
d = state.read_incoming(b) d = state.read_incoming(b)
assert d is not None assert d != None
assert set(d) == set([]) assert set(d) == set([])
s, t = state.read_edge(f) s, t = state.read_edge(f)
assert s is None assert s == None
assert t is None assert t == None
d = state.read_outgoing(e) d = state.read_outgoing(e)
assert d is not None assert d != None
assert set(d) == set([]) assert set(d) == set([])
@ -134,27 +134,27 @@ def test_delete_node_remove_edge_recursive(state):
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(c, b) d = state.create_edge(c, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
d = state.read_value(a) d = state.read_value(a)
assert d is None assert d == None
s, t = state.read_edge(c) s, t = state.read_edge(c)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(d) s, t = state.read_edge(d)
assert s is None assert s == None
assert t is None assert t == None
d = state.read_outgoing(b) d = state.read_outgoing(b)
assert d is not None assert d != None
assert set(d) == set([]) assert set(d) == set([])
@ -168,58 +168,58 @@ def test_delete_node_remove_edge_recursive_deep(state):
f = state.create_node() f = state.create_node()
g = state.create_edge(f, e) g = state.create_edge(f, e)
h = state.create_edge(b, c) h = state.create_edge(b, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
assert f is not None assert f != None
assert g is not None assert g != None
assert h is not None assert h != None
n = state.delete_node(a) n = state.delete_node(a)
assert n is None assert n == None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is None assert l == None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is None assert l == None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([h]) assert set(l) == set([h])
s, t = state.read_edge(d) s, t = state.read_edge(d)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(e) s, t = state.read_edge(e)
assert s is None assert s == None
assert t is None assert t == None
s, t = state.read_edge(g) s, t = state.read_edge(g)
assert s is None assert s == None
assert t is None assert t == None
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
s, t = state.read_edge(h) 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") @pytest.mark.usefixtures("state")
def test_read_dict_no_exists(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") @pytest.mark.usefixtures("state")
def test_read_dict_not_found_node(state): def test_read_dict_not_found_node(state):
a = state.create_node() 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 # 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") @pytest.mark.usefixtures("state")
def test_read_dict_not_found_nodevalue(state): def test_read_dict_not_found_nodevalue(state):
a = state.create_nodevalue(1) 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 # 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") @pytest.mark.usefixtures("state")
@ -29,21 +29,21 @@ def test_read_dict_not_found_edge(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary # 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") @pytest.mark.usefixtures("state")
def test_read_dict_no_primitive(state): def test_read_dict_no_primitive(state):
a = state.create_node() 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 # 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") @pytest.mark.usefixtures("state")
@ -53,11 +53,11 @@ def test_read_dict_node_simple(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_dict(a, "f") l = state.read_dict(a, "f")
assert l == b assert l == b
@ -70,20 +70,20 @@ def test_read_dict_node_multi(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_nodevalue("k") h = state.create_nodevalue("k")
i = state.create_edge(a, g) i = state.create_edge(a, g)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_dict(a, "f") l = state.read_dict(a, "f")
assert l == b assert l == b
@ -91,4 +91,4 @@ def test_read_dict_node_multi(state):
l = state.read_dict(a, "k") l = state.read_dict(a, "k")
assert l == g 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") @pytest.mark.usefixtures("state")
def test_read_dict_edge_no_exists(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") @pytest.mark.usefixtures("state")
def test_read_dict_edge_not_found_node(state): def test_read_dict_edge_not_found_node(state):
a = state.create_node() 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 # 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") @pytest.mark.usefixtures("state")
def test_read_dict_edge_not_found_nodevalue(state): def test_read_dict_edge_not_found_nodevalue(state):
a = state.create_nodevalue(1) 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 # 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") @pytest.mark.usefixtures("state")
@ -29,21 +29,21 @@ def test_read_dict_edge_not_found_edge(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary # 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") @pytest.mark.usefixtures("state")
def test_read_dict_edge_no_primitive(state): def test_read_dict_edge_no_primitive(state):
a = state.create_node() 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 # 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") @pytest.mark.usefixtures("state")
@ -53,11 +53,11 @@ def test_read_dict_edge_node_simple(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_dict_edge(a, "f") l = state.read_dict_edge(a, "f")
assert l == d assert l == d
@ -70,20 +70,20 @@ def test_read_dict_edge_node_multi(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_nodevalue("k") h = state.create_nodevalue("k")
i = state.create_edge(a, g) i = state.create_edge(a, g)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_dict_edge(a, "f") l = state.read_dict_edge(a, "f")
assert l == d assert l == d
@ -91,4 +91,4 @@ def test_read_dict_edge_node_multi(state):
l = state.read_dict_edge(a, "k") l = state.read_dict_edge(a, "k")
assert l == i 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") @pytest.mark.usefixtures("state")
def test_read_dict_keys_no_exists(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") @pytest.mark.usefixtures("state")
@ -13,14 +13,14 @@ def test_read_dict_keys_simple(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_dict_keys(a) l = state.read_dict_keys(a)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
@ -31,21 +31,21 @@ def test_read_dict_keys_multi(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_nodevalue("k") h = state.create_nodevalue("k")
i = state.create_edge(a, g) i = state.create_edge(a, g)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_dict_keys(a) l = state.read_dict_keys(a)
assert l is not None assert l != None
assert set(l) == set([c, h]) 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") @pytest.mark.usefixtures("state")
def test_read_dict_node_no_exists(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") @pytest.mark.usefixtures("state")
@ -11,21 +11,21 @@ def test_read_dict_node_not_found_edge(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary # 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") @pytest.mark.usefixtures("state")
def test_read_dict_node_no_primitive(state): def test_read_dict_node_no_primitive(state):
a = state.create_node() 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 # 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") @pytest.mark.usefixtures("state")
@ -35,11 +35,11 @@ def test_read_dict_node_node_simple(state):
c = state.create_node() c = state.create_node()
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_dict_node(a, c) l = state.read_dict_node(a, c)
assert l == b assert l == b
@ -52,20 +52,20 @@ def test_read_dict_node_multi(state):
c = state.create_node() c = state.create_node()
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_node() h = state.create_node()
i = state.create_edge(a, g) i = state.create_edge(a, g)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_dict_node(a, c) l = state.read_dict_node(a, c)
assert l == b assert l == b

60
state/test/test_read_edge.py
View file

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

160
state/test/test_read_incoming.py
View file

@ -4,10 +4,10 @@ import pytest
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_incoming_node_none(state): def test_read_incoming_node_none(state):
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -16,16 +16,16 @@ def test_read_incoming_node_one(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
@ -36,18 +36,18 @@ def test_read_incoming_node_multi(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) 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) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
f = state.create_node() f = state.create_node()
assert f is not None assert f != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -85,12 +85,12 @@ def test_read_incoming_edge_none(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -101,22 +101,22 @@ def test_read_incoming_edge_one(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(c, a) d = state.create_edge(c, a)
e = state.create_edge(a, c) e = state.create_edge(a, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([e]) assert set(l) == set([e])
l = state.read_incoming(d) l = state.read_incoming(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(e) l = state.read_incoming(e)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -128,41 +128,41 @@ def test_read_incoming_edge_multi(state):
d = state.create_edge(a, c) d = state.create_edge(a, c)
e = state.create_edge(b, c) e = state.create_edge(b, c)
f = state.create_edge(d, c) f = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
assert f is not None assert f != None
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
l = state.read_incoming(c) l = state.read_incoming(c)
assert l is not None assert l != None
assert set(l) == set([d, e, f]) assert set(l) == set([d, e, f])
l = state.read_incoming(d) l = state.read_incoming(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(e) l = state.read_incoming(e)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_incoming_nodevalue_none(state): def test_read_incoming_nodevalue_none(state):
b = state.create_nodevalue(1) b = state.create_nodevalue(1)
assert b is not None assert b != None
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -171,16 +171,16 @@ def test_read_incoming_nodevalue_one(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
b = state.create_node() b = state.create_node()
c = state.create_edge(b, a) c = state.create_edge(b, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -191,18 +191,18 @@ def test_read_incoming_nodevalue_multi(state):
c = state.create_edge(b, a) c = state.create_edge(b, a)
d = state.create_edge(b, a) d = state.create_edge(b, a)
e = state.create_edge(b, a) e = state.create_edge(b, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -213,50 +213,50 @@ def test_read_incoming_nodevalue_multi_others_unaffected(state):
c = state.create_edge(b, a) c = state.create_edge(b, a)
d = state.create_edge(b, a) d = state.create_edge(b, a)
e = state.create_edge(b, a) e = state.create_edge(b, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
f = state.create_nodevalue(1) f = state.create_nodevalue(1)
assert f is not None assert f != None
l = state.read_incoming(a) l = state.read_incoming(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_incoming(f) l = state.read_incoming(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_incoming_node_deleted(state): def test_read_incoming_node_deleted(state):
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
n = state.delete_node(b) n = state.delete_node(b)
assert n is None assert n == None
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is None assert l == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_incoming_nodevalue_deleted(state): def test_read_incoming_nodevalue_deleted(state):
b = state.create_nodevalue(1) b = state.create_nodevalue(1)
assert b is not None assert b != None
n = state.delete_node(b) n = state.delete_node(b)
assert n is None assert n == None
l = state.read_incoming(b) l = state.read_incoming(b)
assert l is None assert l == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -264,12 +264,12 @@ def test_read_incoming_edge_deleted(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_edge(c) n = state.delete_edge(c)
assert n is None assert n == None
l = state.read_incoming(c) 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") @pytest.mark.usefixtures("state")
def test_read_outgoing_node_none(state): def test_read_outgoing_node_none(state):
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -16,16 +16,16 @@ def test_read_outgoing_node_one(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -36,18 +36,18 @@ def test_read_outgoing_node_multi(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -58,25 +58,25 @@ def test_read_outgoing_node_multi_others_unaffected(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
f = state.create_node() f = state.create_node()
assert f is not None assert f != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -85,12 +85,12 @@ def test_read_outgoing_edge_none(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -100,17 +100,17 @@ def test_read_outgoing_edge_one(state):
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(c, a) d = state.create_edge(c, a)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([d]) assert set(l) == set([d])
l = state.read_outgoing(d) l = state.read_outgoing(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -122,37 +122,37 @@ def test_read_outgoing_edge_multi(state):
d = state.create_edge(c, a) d = state.create_edge(c, a)
e = state.create_edge(c, b) e = state.create_edge(c, b)
f = state.create_edge(c, d) f = state.create_edge(c, d)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
assert f is not None assert f != None
l = state.read_outgoing(c) l = state.read_outgoing(c)
assert l is not None assert l != None
assert set(l) == set([d, e, f]) assert set(l) == set([d, e, f])
l = state.read_outgoing(d) l = state.read_outgoing(d)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(e) l = state.read_outgoing(e)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_outgoing_nodevalue_none(state): def test_read_outgoing_nodevalue_none(state):
b = state.create_nodevalue(1) b = state.create_nodevalue(1)
assert b is not None assert b != None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -161,16 +161,16 @@ def test_read_outgoing_nodevalue_one(state):
a = state.create_nodevalue(1) a = state.create_nodevalue(1)
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c]) assert set(l) == set([c])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -181,18 +181,18 @@ def test_read_outgoing_nodevalue_multi(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@ -203,50 +203,50 @@ def test_read_outgoing_nodevalue_multi_others_unaffected(state):
c = state.create_edge(a, b) c = state.create_edge(a, b)
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(a, b) e = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
f = state.create_nodevalue(1) f = state.create_nodevalue(1)
assert f is not None assert f != None
l = state.read_outgoing(a) l = state.read_outgoing(a)
assert l is not None assert l != None
assert set(l) == set([c, d, e]) assert set(l) == set([c, d, e])
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
l = state.read_outgoing(f) l = state.read_outgoing(f)
assert l is not None assert l != None
assert set(l) == set([]) assert set(l) == set([])
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_outgoing_node_deleted(state): def test_read_outgoing_node_deleted(state):
b = state.create_node() b = state.create_node()
assert b is not None assert b != None
n = state.delete_node(b) n = state.delete_node(b)
assert n is None assert n == None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is None assert l == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_outgoing_nodevalue_deleted(state): def test_read_outgoing_nodevalue_deleted(state):
b = state.create_nodevalue(1) b = state.create_nodevalue(1)
assert b is not None assert b != None
n = state.delete_node(b) n = state.delete_node(b)
assert n is None assert n == None
l = state.read_outgoing(b) l = state.read_outgoing(b)
assert l is None assert l == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
@ -254,12 +254,12 @@ def test_read_outgoing_edge_deleted(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
n = state.delete_edge(c) n = state.delete_edge(c)
assert n is None assert n == None
l = state.read_outgoing(c) 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") @pytest.mark.usefixtures("state")
def test_read_reverse_dict_no_exists(state): def test_read_reverse_dict_no_exists(state):
l = state.read_reverse_dict(-1, "abc") l = state.read_reverse_dict(-1, "abc")
assert l is None assert l == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_reverse_dict_not_found_node(state): def test_read_reverse_dict_not_found_node(state):
a = state.create_node() 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 # Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, "abc") l = state.read_reverse_dict(a, "abc")
@ -20,7 +20,7 @@ def test_read_reverse_dict_not_found_node(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_reverse_dict_not_found_nodevalue(state): def test_read_reverse_dict_not_found_nodevalue(state):
a = state.create_nodevalue(1) 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 # Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, "abc") l = state.read_reverse_dict(a, "abc")
@ -32,9 +32,9 @@ def test_read_reverse_dict_not_found_edge(state):
a = state.create_node() a = state.create_node()
b = state.create_node() b = state.create_node()
c = state.create_edge(a, b) c = state.create_edge(a, b)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
# Passing data is not enforced, as the data will be interpreted if necessary # Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(c, "abc") l = state.read_reverse_dict(c, "abc")
@ -44,7 +44,7 @@ def test_read_reverse_dict_not_found_edge(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_reverse_dict_no_primitive(state): def test_read_reverse_dict_no_primitive(state):
a = state.create_node() 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 # Passing data is not enforced, as the data will be interpreted if necessary
l = state.read_reverse_dict(a, a) l = state.read_reverse_dict(a, a)
@ -58,11 +58,11 @@ def test_read_reverse_dict_node_simple(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_reverse_dict(b, "f") l = state.read_reverse_dict(b, "f")
assert set(l) == set([a]) assert set(l) == set([a])
@ -75,11 +75,11 @@ def test_read_reverse_dict_no_match(state):
c = state.create_nodevalue("g") c = state.create_nodevalue("g")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
l = state.read_reverse_dict(b, "f") l = state.read_reverse_dict(b, "f")
assert l == [] assert l == []
@ -92,20 +92,20 @@ def test_read_reverse_dict_node_multi(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_nodevalue("k") h = state.create_nodevalue("k")
i = state.create_edge(a, g) i = state.create_edge(a, g)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_reverse_dict(b, "f") l = state.read_reverse_dict(b, "f")
assert set(l) == set([a]) assert set(l) == set([a])
@ -124,20 +124,20 @@ def test_read_reverse_dict_node_multi_ambiguous(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(b, a) d = state.create_edge(b, a)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
g = state.create_node() g = state.create_node()
h = state.create_nodevalue("f") h = state.create_nodevalue("f")
i = state.create_edge(g, a) i = state.create_edge(g, a)
j = state.create_edge(i, h) j = state.create_edge(i, h)
assert g is not None assert g != None
assert h is not None assert h != None
assert i is not None assert i != None
assert j is not None assert j != None
l = state.read_reverse_dict(a, "f") l = state.read_reverse_dict(a, "f")
assert set(l) == set([b, g]) assert set(l) == set([b, g])
@ -150,16 +150,16 @@ def test_read_reverse_dict_node_uncertain(state):
c = state.create_nodevalue("f") c = state.create_nodevalue("f")
d = state.create_edge(a, b) d = state.create_edge(a, b)
e = state.create_edge(d, c) e = state.create_edge(d, c)
assert a is not None assert a != None
assert b is not None assert b != None
assert c is not None assert c != None
assert d is not None assert d != None
assert e is not None assert e != None
h = state.create_nodevalue("g") h = state.create_nodevalue("g")
i = state.create_edge(d, h) i = state.create_edge(d, h)
assert h is not None assert h != None
assert i is not None assert i != None
l = state.read_reverse_dict(b, "f") l = state.read_reverse_dict(b, "f")
assert set(l) == set([a]) 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): def test_read_value_different_id_simple(state):
id1 = state.create_nodevalue(1) id1 = state.create_nodevalue(1)
id2 = state.create_nodevalue(2) id2 = state.create_nodevalue(2)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
v1 = state.read_value(id1) v1 = state.read_value(id1)
v2 = state.read_value(id2) v2 = state.read_value(id2)
@ -19,7 +19,7 @@ def test_read_value_integer_ib_negative(state):
# Just within range # Just within range
for i in range(-2 ** 63, -2 ** 63 + 10): for i in range(-2 ** 63, -2 ** 63 + 10):
id1 = state.create_nodevalue(i) id1 = state.create_nodevalue(i)
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == i assert v == i
@ -30,7 +30,7 @@ def test_read_value_integer_ib_zero(state):
# Nicely within range # Nicely within range
for i in range(-10, 10): for i in range(-10, 10):
id1 = state.create_nodevalue(i) id1 = state.create_nodevalue(i)
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == i assert v == i
@ -41,7 +41,7 @@ def test_read_value_integer_ib_positive(state):
# Just within range # Just within range
for i in range(2 ** 63 - 10, 2 ** 63): for i in range(2 ** 63 - 10, 2 ** 63):
id1 = state.create_nodevalue(i) id1 = state.create_nodevalue(i)
assert id1 is not None assert id1 != None
v = state.read_value(id1) v = state.read_value(id1)
assert v == i assert v == i
@ -51,8 +51,8 @@ def test_read_value_integer_ib_positive(state):
def test_read_value_boolean(state): def test_read_value_boolean(state):
id1 = state.create_nodevalue(True) id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(False) id2 = state.create_nodevalue(False)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
v1 = state.read_value(id1) v1 = state.read_value(id1)
v2 = state.read_value(id2) v2 = state.read_value(id2)
@ -64,8 +64,8 @@ def test_read_value_boolean(state):
def test_read_nodevalue_boolean_same(state): def test_read_nodevalue_boolean_same(state):
id1 = state.create_nodevalue(True) id1 = state.create_nodevalue(True)
id2 = state.create_nodevalue(True) id2 = state.create_nodevalue(True)
assert id1 is not None assert id1 != None
assert id2 is not None assert id2 != None
v1 = state.read_value(id1) v1 = state.read_value(id1)
v2 = state.read_value(id2) v2 = state.read_value(id2)
@ -76,13 +76,13 @@ def test_read_nodevalue_boolean_same(state):
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_value_no_exist(state): def test_read_value_no_exist(state):
v1 = state.read_value(100000) v1 = state.read_value(100000)
assert v1 is None assert v1 == None
@pytest.mark.usefixtures("state") @pytest.mark.usefixtures("state")
def test_read_value_no_value(state): def test_read_value_no_value(state):
id1 = state.create_node() id1 = state.create_node()
assert id1 is not None assert id1 != None
v1 = state.read_value(id1) 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 # - min-card: 0
# - max-card: same as original # - max-card: same as original
upper_card = find_cardinality(class_node, class_upper_card_node) 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) ramified_scd.create_class(class_name, abstract=None, max_c=upper_card)
for (attr_name, attr_type) in get_attributes(class_node): 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)) src = scd.get_class_name(bottom.read_edge_source(assoc_node))
tgt = scd.get_class_name(bottom.read_edge_target(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) 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, ramified_scd.create_association(assoc_name, src, tgt,
src,
tgt,
src_max_c=src_upper_card, src_max_c=src_upper_card,
tgt_max_c=tgt_upper_card) tgt_max_c=tgt_upper_card)