def _create_decision(self, node_id, activity):
''' create a decision after the action, if the action has more than 2 outgoings
1. change the 2 edges source to the decisionId
2. create a edge between action and decision, at the same time,
create a outgoing,incoming, their xmi_idref is the id of edge,
and change the outgoings of the action, incomings of the decision
3. create a decision
4. put the decision, edge to the dicts
@param node_id: the id of the node
@type node_id: str
'''
nodes_dict = activity.nodes_dict
edges_dict = activity.edges_dict
# get the node
node = nodes_dict[node_id]
# get the decision id
# decision_id1,decision_id2
decision_xmi_id = self._get_new_id("decision", nodes_dict)
# "uml:DecisionNode"
xmi_type = uml_element.Types.DECISION_NODE
name = decision_xmi_id
decision_outgoings = []
node_outgoings = []
# 1. change the 2 edges attribute source to the decision
outgoings = node.outgoings
for outgoing in outgoings:
outgoing_id = outgoing.xmi_idref
edge = edges_dict[outgoing_id]
if edge.xmi_type == uml_element.Types.CONTROL_FLOW:
edge.source = decision_xmi_id
decision_outgoings.append(outgoing)
# object flow
else:
node_outgoings.append(outgoing)
# 2. create a Incoming instance for merge, a ActivityEdge instance,
# and a Outgoing instance for node
# 2a. create a Incoming instance. edge_id is the xmi_id in edge,
# also the xmi_idref of the instance Incoming
# get the id of the edge
edge_id = self._get_new_id("edge", edges_dict)
edge_name = edge_id
# create incoming
incoming = uml_element.Incoming(edge_id)
incomings = [incoming]
# 2b. create a ActivityEdge instance. target: decision_xmi_id, source: node_id
new_edge = uml_element.ControlFlow(edge_id, uml_element.Types.CONTROL_FLOW, \
edge_name, decision_xmi_id, node_id, None)
# 2c. the same time, create outgoing
# edge---incoming or outgoing
outgoing = uml_element.Outgoing(edge_id)
node_outgoings.append(outgoing)
node.outgoings = node_outgoings
# 3. create decision
decision = uml_element.Decision(decision_xmi_id, xmi_type, name,
incomings, decision_outgoings)
# put into the dicts
nodes_dict[decision_xmi_id] = decision
edges_dict[edge_id] = new_edge
def test_fork_has_more_incomings(self):
'''fork_has_more_incomings()
'''
activity = self.activity
self.assertEqual(self.tclass.fork_has_more_incomings(activity), [],
"fork_has_more_incomings() assertEqual1 failed")
# action1->edge1->fork
# action2->edge2->fork
action1 = uml_element.Action("action1", uml_element.Types.ACTION,
"action1", ["1"],
[uml_element.Outgoing("edge1")], None,
None)
edge1 = uml_element.ControlFlow("edge1",
uml_element.Types.CONTROL_FLOW, "fork",
"action1", "initial", None)
action2 = uml_element.Action("action2", uml_element.Types.ACTION,
"action2", ["2"],
[uml_element.Outgoing("edge2")], None,
None)
edge2 = uml_element.ControlFlow("edge2",
uml_element.Types.CONTROL_FLOW, "fork",
"action2", "action1", None)
fork = uml_element.FinalNode(
"fork", uml_element.Types.FORK_NODE, "fork",
[uml_element.Incoming("edge1"),
uml_element.Incoming("edge2")], ["3"])
activity1 = uml_element.Activity(0, uml_element.Types.ACTIVITY, 0, {},
{}, {})
activity1.edges_dict["edge1"] = edge1
activity1.edges_dict["edge2"] = edge2
activity1.nodes_dict["action1"] = action1
activity1.nodes_dict["action2"] = action2
activity1.nodes_dict["fork"] = fork
self.assertEqual(self.tclass.fork_has_more_incomings(activity1),
["fork"],
"fork_has_more_incomings() assertEqual2 failed")
def create_edge_object(self, edges_dict, xmi_id, xmi_type, name, target, source, guard):
'''create instance of uml_activity_diagram_element.ActivityEdge
from the xmi_type
'''
if xmi_type == uml_element.Types.CONTROL_FLOW:
edge = uml_element.ControlFlow(xmi_id, xmi_type, name, target, source, guard)
edges_dict[xmi_id] = edge
# get the probability from the guard of the control flow(edge)
cf_prob = self._get_cf_prob_from_text(guard)
edge.prob = cf_prob
elif xmi_type == uml_element.Types.OBJECT_FLOW:
edge = uml_element.ObjectFlow(xmi_id, xmi_type, name, target, source, guard)
edges_dict[xmi_id] = edge
else:
log.show_warn("the edge is not control flow, neither object flow")
def _add_control_flow(self, node1, node2, activity):
'''add one control flow from node1 to node2.
'''
edges_dict = activity.edges_dict
# get the edge_id, and create a edge
edge_id = self._get_new_id("edge", edges_dict)
edge = uml_element.ControlFlow(edge_id, uml_element.Types.CONTROL_FLOW,
edge_id, node2.xmi_id, node1.xmi_id,
None)
# node1.outgoings and node2.incomings
outgoing = uml_element.Outgoing(edge_id)
node1.outgoings.append(outgoing)
incoming = uml_element.Incoming(edge_id)
node2.incomings.append(incoming)
# put the edge to the edge_dict
edges_dict[edge_id] = edge
# shwo info
log.show_info("one control flow is created from %s to %s." %
(str(node1.name), str(node2.name)))
def _create_merge(self, node_id, activity, flow_type):
''' create a merge before the action(fork), if the action(fork) has
more than 2 incomings control flow
1. change the 2 or more edges(control flow) target to the mergeId
2. create a edge between merge and action(fork), at the same time,
create a outgoing,incoming, their xmi_idref is the id of edge,
and change the incomings of the action(fork), outgoings of the merge
3. create a merge
4. put the merge, edge to the dicts
@attention: do not change the object flow edge
@param node_id: the id of the node
@type node_id: str
@param flow_type: the type of the flow(edge).
@type flow_type: 1.uml_element.Types.CONTROL_FLOW 2.uml_element.Types.OBJECT_FLOW
'''
nodes_dict = activity.nodes_dict
edges_dict = activity.edges_dict
# get the node
node = nodes_dict[node_id]
# get the merge id
# merge_id1,merge_id2
merge_xmi_id = self._get_new_id("merge", nodes_dict)
# "uml:MergeNode"
xmi_type = uml_element.Types.MERGE_NODE
name = merge_xmi_id
merge_incomings = []
node_incomings = []
# 1. change the 2 edges attribute target to the merge
incomings = node.incomings
for incoming in incomings:
incoming_id = incoming.xmi_idref
edge = edges_dict[incoming_id]
if edge.xmi_type == uml_element.Types.CONTROL_FLOW:
edge.target = merge_xmi_id
merge_incomings.append(incoming)
# object flow
else:
node_incomings.append(incoming)
# 2. create a Outgoing instance for merge, a ActivityEdge instance,
# and a Incoming instance for node
# 2a. create a Outgoing instance. edge_id is the xmi_id in edge,
# also the xmi_idref of the instance Outgoing
# get the id of the edge
edge_id = self._get_new_id("edge", edges_dict)
edge_name = edge_id
# create outgoing
outgoing = uml_element.Outgoing(edge_id)
outgoings = [outgoing]
# 2b. create a ActivityEdge instance. target: node_id, source: merge_xmi_id
new_edge = uml_element.ControlFlow(edge_id, flow_type, edge_name,
node_id, merge_xmi_id, None)
# 2c. the same time, create incoming
# edge---incoming or outgoing
incoming = uml_element.Incoming(edge_id)
node_incomings.append(incoming)
node.incomings = node_incomings
# 3. create merge
merge = uml_element.Merge(merge_xmi_id, xmi_type, name,
merge_incomings, outgoings)
# put into the dicts
nodes_dict[merge_xmi_id] = merge
edges_dict[edge_id] = new_edge
def setUp(self):
'''setup
'''
# new the to unit test class object
self.tclass = activity_transform_epf.AdToEpfTransformer()
# init->edge1->action1->edge2->action2->edge4->final
# action2->edge3->action1
# action1->edge5->object1->edge6->action2
initial = uml_element.InitialNode("initial", uml_element.Types.INITIAL_NODE, \
"initial", [], [uml_element.Outgoing("edge1")])
edge1 = uml_element.ControlFlow("edge1", uml_element.Types.CONTROL_FLOW, \
"edge1", "action1", "initial", None)
action1 = uml_element.Action(
"action1", uml_element.Types.ACTION, "action1",
[uml_element.Incoming("edge1"),
uml_element.Incoming("edge3")],
[uml_element.Outgoing("edge2"),
uml_element.Outgoing("edge5")], None, None)
edge2 = uml_element.ControlFlow("edge2",
uml_element.Types.CONTROL_FLOW,
"edge2", "action2", "action1", None)
action2 = uml_element.Action(
"action2", uml_element.Types.ACTION, "action2",
[uml_element.Incoming("edge2"),
uml_element.Incoming("edge6")],
[uml_element.Outgoing("edge3"),
uml_element.Outgoing("edge4")], None, None)
edge4 = uml_element.ControlFlow("edge4",
uml_element.Types.CONTROL_FLOW,
"edge4", "final", "action2", None)
final = uml_element.ActivityFinal(
"final", uml_element.Types.ACTIVITY_FINAL_NODE, "final",
[uml_element.Incoming("edge4")], [])
edge3 = uml_element.ControlFlow("edge3",
uml_element.Types.CONTROL_FLOW,
"edge3", "action1", "action2", None)
edge5 = uml_element.ControlFlow("edge5", uml_element.Types.OBJECT_FLOW,
"edge5", "object1", "action1", None)
edge6 = uml_element.ControlFlow("edge6", uml_element.Types.OBJECT_FLOW,
"edge6", "action2", "object1", None)
object1 = uml_element.ObjectNode("object1",
uml_element.Types.OBJECT_NODE,
"object1",
[uml_element.Incoming("edge5")],
[uml_element.Outgoing("edge6")])
activity = uml_element.Activity(0, uml_element.Types.ACTIVITY, 0, {},
{}, {})
activity.edges_dict["edge1"] = edge1
activity.edges_dict["edge2"] = edge2
activity.edges_dict["edge3"] = edge3
activity.edges_dict["edge4"] = edge4
activity.edges_dict["edge5"] = edge5
activity.edges_dict["edge6"] = edge6
activity.nodes_dict["initial"] = initial
activity.nodes_dict["action1"] = action1
activity.nodes_dict["action2"] = action2
activity.nodes_dict["object1"] = object1
activity.nodes_dict["final"] = final
self.activity = activity