def test_dataflow_assignment_node_attribute(graph: DataflowGraph, instantiate: bool) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) if instantiate: y.assign(create_instance().reference(), Statement(), graph) x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n") assignment_node: AssignableNode = x_n.assignment_node() instance: InstanceNode if instantiate: assert isinstance(y, VariableNodeReference) assert len(y.node.instance_assignments) == 1 instance = y.node.instance_assignments[0].rhs.node() else: assert isinstance(z, VariableNodeReference) assert z.node.equivalence.tentative_instance is not None instance = z.node.equivalence.tentative_instance # verify tentative nodes only get created once assignment_node2: AssignableNode = x_n.assignment_node() assert assignment_node == assignment_node2 assert assignment_node == instance.get_attribute("n")
def test_dataflow_tentative_attribute_propagation_on_equivalence( graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) z.assign(x, Statement(), graph) x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n") x_n.assign(ValueNode(42).reference(), Statement(), graph) assert isinstance(y, VariableNodeReference) assert len(y.node.instance_assignments) == 0 y.assign(create_instance().reference(), Statement(), graph) assert len(y.node.instance_assignments) == 1 y_n: Optional[AttributeNode] = y.node.instance_assignments[0].rhs.node( ).get_attribute("n") assert y_n is not None assert len(y_n.value_assignments) == 1 assert y_n.value_assignments[0].rhs.node.value == 42
def test_dataflow_assignment_node_simple(graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") x.assign(y, Statement(), graph) assert isinstance(x, VariableNodeReference) assert x.assignment_node() == x.node
def test_dataflow_variable_chain_leaf(graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) leaves: Set[AssignableNode] = set(x.leaf_nodes()) assert isinstance(z, DirectNodeReference) assert leaves == {z.node}
def test_dataflow_variable_tree_leaves(graph: DataflowGraph, value_node: Node) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) y.assign(value_node.reference(), Statement(), graph) leaves: Set[AssignableNode] = set(x.leaf_nodes()) assert isinstance(y, DirectNodeReference) assert isinstance(z, DirectNodeReference) assert leaves == {y.node, z.node}
def test_dataflow_model_attribute_assignment_responsible( dataflow_test_helper: DataflowTestHelper) -> None: dataflow_test_helper.compile(""" entity Test: number n end implement Test using std::none x = Test() x.n = 42 """) graph: DataflowGraph = dataflow_test_helper.get_graph() x: AssignableNodeReference = get_dataflow_node(graph, "x") assert isinstance(x, VariableNodeReference) assert len(x.node.instance_assignments) == 1 n: Optional[AttributeNode] = x.node.instance_assignments[0].rhs.node( ).get_attribute("n") assert n is not None assert len(n.value_assignments) == 1 assignment: Assignment[ValueNodeReference] = n.value_assignments[0] assert isinstance(assignment.responsible, SetAttribute) assert assignment.responsible.instance.name == "x" assert assignment.responsible.attribute_name == "n" assert isinstance(assignment.responsible.value, Literal) assert assignment.responsible.value.value == 42 assert assignment.context == graph
def test_dataflow_variable_loop_with_external_assignment_leaves( graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) z.assign(x, Statement(), graph) u: AssignableNodeReference = get_dataflow_node(graph, "u") y.assign(u, Statement(), graph) leaves: Set[AssignableNode] = set(x.leaf_nodes()) assert isinstance(u, DirectNodeReference) assert leaves == {u.node}
def test_dataflow_variable_loop_with_value_assignment_leaves( graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) z.assign(x, Statement(), graph) y.assign(ValueNode(42).reference(), Statement(), graph) leaves: Set[AssignableNode] = set(x.leaf_nodes()) assert isinstance(x, DirectNodeReference) assert isinstance(y, DirectNodeReference) assert isinstance(z, DirectNodeReference) assert leaves == {y.node}
def test_dataflow_assignment_node_nested_tentative( graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") x_a_n: AssignableNodeReference = get_dataflow_node(graph, "x.a.n") assignment_node: AssignableNode = x_a_n.assignment_node() assert isinstance(x, VariableNodeReference) instance: Optional[InstanceNode] = x.node.equivalence.tentative_instance assert instance is not None a: Optional[AttributeNode] = instance.get_attribute("a") assert a is not None instance2: Optional[InstanceNode] = a.equivalence.tentative_instance assert instance2 is not None n: Optional[AttributeNode] = instance2.get_attribute("n") assert assignment_node == n
def test_dataflow_attribute_reference_nodes(graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") x.assign(y, Statement(), graph) y.assign(create_instance().reference(), Statement(), graph) assert isinstance(y, VariableNodeReference) assert len(y.node.instance_assignments) == 1 y_n: AssignableNodeReference = get_dataflow_node(graph, "y.n") y_n.assign(ValueNode(42).reference(), Statement(), graph) x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n") x_n_nodes: List[AssignableNode] = list(x_n.nodes()) assert len(x_n_nodes) == 1 assert x_n_nodes[0] == y.node.instance_assignments[0].rhs.node( ).get_attribute("n")
def test_dataflow_tentative_attribute_propagation_over_uninitialized_attribute( graph: DataflowGraph) -> None: x_y: AssignableNodeReference = get_dataflow_node(graph, "x.y") u_n: AssignableNodeReference = get_dataflow_node(graph, "u.n") y: AssignableNodeReference = get_dataflow_node(graph, "y") u: AssignableNodeReference = get_dataflow_node(graph, "u") u_n.assign(ValueNode(42).reference(), Statement(), graph) x_y.assign(y, Statement(), graph) u.assign(x_y, Statement(), graph) assert isinstance(y, VariableNodeReference) instance: Optional[InstanceNode] = y.node.equivalence.tentative_instance assert instance is not None n: Optional[AttributeNode] = instance.get_attribute("n") assert n is not None assert len(n.value_assignments) == 1 assert n.value_assignments[0].rhs.node.value == 42
def test_dataflow_primitive_assignment(graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") statement: Statement = Statement() x.assign(ValueNode(42).reference(), statement, graph) assert isinstance(x, DirectNodeReference) assert len(x.node.value_assignments) == 1 assignment: Assignment[ValueNodeReference] = x.node.value_assignments[0] assert assignment.lhs == x.node assert assignment.rhs.node == ValueNode(42) assert assignment.responsible == statement assert assignment.context == graph
def test_attribute_assignment(graph: DataflowGraph, instantiate: bool) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n") if instantiate: x.assign(create_instance().reference(), Statement(), graph) x_n.assign(ValueNode(42).reference(), Statement(), graph) assert isinstance(x, VariableNodeReference) instance: InstanceNode if instantiate: assert x.node.equivalence.tentative_instance is None assert len(x.node.instance_assignments) == 1 instance = x.node.instance_assignments[0].rhs.node() else: assert x.node.equivalence.tentative_instance is not None instance = x.node.equivalence.tentative_instance n: Optional[AttributeNode] = instance.get_attribute("n") assert n is not None assert len(n.value_assignments) == 1 assert n.value_assignments[0].rhs == ValueNode(42).reference()
def test_dataflow_index_nodes(graph: DataflowGraph) -> None: entity: Entity = Entity("DummyEntity", Namespace("dummy_namespace")) i1: InstanceNode = create_instance(graph, entity) i2: InstanceNode = create_instance(graph, entity) i1.register_attribute("n").assign( ValueNode(0).reference(), Statement(), graph) i1.register_attribute("n").assign( ValueNode(0).reference(), Statement(), graph) x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") x.assign(i1.reference(), Statement(), graph) y.assign(i2.reference(), Statement(), graph) graph.add_index_match([i.reference() for i in [i1, i2]]) x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n") y_n: AssignableNodeReference = get_dataflow_node(graph, "y.n") assert set(x_n.nodes()) == set(y_n.nodes())
def test_dataflow_nodestub(dataflow_test_helper: DataflowTestHelper, value_string: str, other_stmts: List[str]) -> None: dataflow_test_helper.compile( """ x = %s %s """ % (value_string, "\n".join(other_stmts)), ) graph: DataflowGraph = dataflow_test_helper.get_graph() x: AssignableNodeReference = get_dataflow_node(graph, "x") assert isinstance(x, VariableNodeReference) assignments: List[Assignment] = list(x.node.assignments()) assert len(assignments) == 1 assert isinstance(assignments[0].rhs, ValueNodeReference) assert isinstance(assignments[0].rhs.node, NodeStub)
def test_dataflow_model_primitive_assignment_responsible( dataflow_test_helper: DataflowTestHelper) -> None: dataflow_test_helper.compile(""" x = 42 """, ) graph: DataflowGraph = dataflow_test_helper.get_graph() x: AssignableNodeReference = get_dataflow_node(graph, "x") assert isinstance(x, VariableNodeReference) assert len(x.node.value_assignments) == 1 assignment: Assignment[ValueNodeReference] = x.node.value_assignments[0] assert isinstance(assignment.responsible, Assign) assert assignment.responsible.name == "x" assert isinstance(assignment.responsible.value, Literal) assert assignment.responsible.value.value == 42 assert assignment.context == graph
def test_dataflow_model_implementation_assignment_from_self( dataflow_test_helper: DataflowTestHelper, explicit: bool) -> None: dataflow_test_helper.compile( """ entity A: number n end entity B: number n end A.b [1] -- B implementation i for A: self.b = B(n = %s) end implement A using i implement B using std::none n = 0 x = A(n = 42) b = x.b """ % ("self.n" if explicit else "n"), ) dataflow_test_helper.verify_graphstring( """ n -> 0 x -> <instance> x <instance> x . n -> 42 <instance> x . b -> <instance> b b -> x . b """, ) dataflow_test_helper.verify_leaves({"b.n": {"x.n"}}) leaves: List[AssignableNode] = list( get_dataflow_node(dataflow_test_helper.get_graph(), "b.n").leaf_nodes()) assert len(leaves) == 1 assert len(leaves[0].value_assignments) == 1 assert leaves[0].value_assignments[0].rhs.node.value == 42
def test_dataflow_tentative_attribute_propagation( graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") y: AssignableNodeReference = get_dataflow_node(graph, "y") z: AssignableNodeReference = get_dataflow_node(graph, "z") x.assign(y, Statement(), graph) y.assign(z, Statement(), graph) x_a_n: AssignableNodeReference = get_dataflow_node(graph, "x.a.n") x_a_n.assign(ValueNode(42).reference(), Statement(), graph) def assert_tentative_a_n(var: AssignableNode, values: Optional[Set[int]] = None) -> None: if values is None: values = {42} instance: Optional[InstanceNode] = var.equivalence.tentative_instance assert instance is not None a: Optional[AttributeNode] = instance.get_attribute("a") assert a is not None instance2: Optional[InstanceNode] = a.equivalence.tentative_instance assert instance2 is not None n: Optional[AttributeNode] = instance2.get_attribute("n") assert n is not None assert len(n.value_assignments) == len(values) assert { assignment.rhs.node.value for assignment in n.value_assignments } == values assert isinstance(z, VariableNodeReference) assert_tentative_a_n(z.node) u: AssignableNodeReference = get_dataflow_node(graph, "u") v: AssignableNodeReference = get_dataflow_node(graph, "v") u.assign(v, Statement(), graph) z.assign(u, Statement(), graph) assert isinstance(z, VariableNodeReference) assert z.node.equivalence.tentative_instance is None assert isinstance(v, VariableNodeReference) assert_tentative_a_n(v.node) x_a_n.assign(ValueNode(0).reference(), Statement(), graph) assert_tentative_a_n(v.node, {0, 42})
def test_dataflow_model_primitive_double_assignment_responsible( dataflow_test_helper: DataflowTestHelper) -> None: dataflow_test_helper.compile( """ x = 42 x = 0 """, DoubleSetException, ) graph: DataflowGraph = dataflow_test_helper.get_graph() x: AssignableNodeReference = get_dataflow_node(graph, "x") assert isinstance(x, VariableNodeReference) assignments: List[Assignment] = x.node.value_assignments assert len(assignments) == 2 zero_index: int = [assignment.rhs for assignment in assignments ].index(ValueNode(0).reference()) for i, assignment in enumerate(assignments): value: int = 0 if i == zero_index else 42 assert assignment.context == graph assert isinstance(assignment.responsible, Assign) assert assignment.responsible.name == "x" assert isinstance(assignment.responsible.value, Literal) assert assignment.responsible.value.value == value
def test_dataflow_reference_nodes(graph: DataflowGraph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") x_nodes: List[AssignableNode] = list(x.nodes()) assert len(x_nodes) == 1 assert isinstance(x, DirectNodeReference) assert x_nodes[0] == x.node
def get_attribute_node(graph: DataflowGraph, attr: str) -> AttributeNode: node_ref: AssignableNodeReference = get_dataflow_node(graph, attr) node: AssignableNode = next(node_ref.nodes()) assert isinstance(node, AttributeNode) return node
def test_dataflow_simple_leaf(graph) -> None: x: AssignableNodeReference = get_dataflow_node(graph, "x") leaves: List[AssignableNode] = list(x.leaf_nodes()) assert isinstance(x, DirectNodeReference) assert leaves == [x.node]