Examples with CompositeContextNode org.jbpm.workflow.core.node.CompositeContextNode used on opensource projects

Example 1 with CompositeContextNode

use of org.jbpm.workflow.core.node.CompositeContextNode in project jbpm by kiegroup.

the class CompositeNodeHandler method createNode.

protected Node createNode() {
    CompositeContextNode result = new CompositeContextNode();
    VariableScope variableScope = new VariableScope();
    result.addContext(variableScope);
    result.setDefaultContext(variableScope);
    return result;
}

Example 2 with CompositeContextNode

use of org.jbpm.workflow.core.node.CompositeContextNode in project jbpm by kiegroup.

the class SubProcessHandler method createNode.

protected Node createNode(Attributes attrs) {
    CompositeContextNode subProcessNode = new CompositeContextNode();
    String eventSubprocessAttribute = attrs.getValue("triggeredByEvent");
    if (eventSubprocessAttribute != null && Boolean.parseBoolean(eventSubprocessAttribute)) {
        subProcessNode = new EventSubProcessNode();
    }
    VariableScope variableScope = new VariableScope();
    subProcessNode.addContext(variableScope);
    subProcessNode.setDefaultContext(variableScope);
    String compensation = attrs.getValue("isForCompensation");
    if (compensation != null) {
        boolean isForCompensation = Boolean.parseBoolean(compensation);
        if (isForCompensation) {
            subProcessNode.setMetaData("isForCompensation", isForCompensation);
        }
    }
    subProcessNode.setAutoComplete(true);
    return subProcessNode;
}

Example 3 with CompositeContextNode

use of org.jbpm.workflow.core.node.CompositeContextNode in project jbpm by kiegroup.

the class SubProcessHandler method handleCompositeContextNode.

@SuppressWarnings("unchecked")
protected void handleCompositeContextNode(final Node node, final Element element, final String uri, final String localName, final ExtensibleXmlParser parser) throws SAXException {
    super.handleNode(node, element, uri, localName, parser);
    CompositeContextNode compositeNode = (CompositeContextNode) node;
    List<SequenceFlow> connections = (List<SequenceFlow>) compositeNode.getMetaData(ProcessHandler.CONNECTIONS);
    handleScript(compositeNode, element, "onEntry");
    handleScript(compositeNode, element, "onExit");
    List<IntermediateLink> throwLinks = (List<IntermediateLink>) compositeNode.getMetaData(ProcessHandler.LINKS);
    ProcessHandler.linkIntermediateLinks(compositeNode, throwLinks);
    ProcessHandler.linkConnections(compositeNode, connections);
    ProcessHandler.linkBoundaryEvents(compositeNode);
    // This must be done *after* linkConnections(process, connections)
    // because it adds hidden connections for compensations
    List<Association> associations = (List<Association>) compositeNode.getMetaData(ProcessHandler.ASSOCIATIONS);
    ProcessHandler.linkAssociations((Definitions) compositeNode.getMetaData("Definitions"), compositeNode, associations);
// TODO: do we fully support interruping ESP's?
/**
 *        for( org.kie.api.definition.process.Node subNode : compositeNode.getNodes() ) {
 *            if( subNode instanceof StartNode ) {
 *                if( ! ((StartNode) subNode).isInterrupting() ) {
 *                    throw new IllegalArgumentException("Non-interrupting event subprocesses are not yet fully supported." );
 *                }
 *            }
 *        }
 */
}

Example 4 with CompositeContextNode

use of org.jbpm.workflow.core.node.CompositeContextNode in project jbpm by kiegroup.

the class XMLPersistenceTest method testPersistenceOfFullNodes.

@Test
public void testPersistenceOfFullNodes() throws Exception {
    RuleFlowProcess process = new RuleFlowProcess() {

        private static final long serialVersionUID = 510l;

        int id = 0;

        public void addNode(org.kie.api.definition.process.Node node) {
            ((Node) node).setId(++id);
            super.addNode(node);
        }
    };
    process.setMetaData("routerLayout", 1);
    Set<String> imports = new HashSet<String>();
    imports.add("import1");
    imports.add("import2");
    process.setImports(imports);
    Map<String, String> globals = new HashMap<String, String>();
    globals.put("name1", "type1");
    globals.put("name2", "type2");
    process.setGlobals(globals);
    List<Variable> variables = new ArrayList<Variable>();
    Variable variable = new Variable();
    variable.setName("variable1");
    variable.setType(new StringDataType());
    variable.setValue("value");
    variables.add(variable);
    variable = new Variable();
    variable.setName("variable2");
    variable.setType(new IntegerDataType());
    variable.setValue(2);
    variables.add(variable);
    variable = new Variable();
    variable.setName("variable3");
    variable.setType(new ObjectDataType("org.jbpm.integrationtests.test.Person"));
    Person person = new Person();
    person.setName("John");
    variable.setValue(person);
    variables.add(variable);
    variable = new Variable();
    variable.setName("variable4");
    ListDataType listDataType = new ListDataType();
    listDataType.setType(new ObjectDataType("java.lang.Integer"));
    variable.setType(listDataType);
    List<Integer> list = new ArrayList<Integer>();
    list.add(10);
    list.add(20);
    variable.setValue(list);
    variables.add(variable);
    process.getVariableScope().setVariables(variables);
    Swimlane swimlane = new Swimlane();
    swimlane.setName("actor1");
    process.getSwimlaneContext().addSwimlane(swimlane);
    swimlane = new Swimlane();
    swimlane.setName("actor2");
    process.getSwimlaneContext().addSwimlane(swimlane);
    ActionExceptionHandler exceptionHandler = new ActionExceptionHandler();
    exceptionHandler.setFaultVariable("faultVariable");
    DroolsConsequenceAction action = new DroolsConsequenceAction("dialect", "consequence");
    exceptionHandler.setAction(action);
    process.getExceptionScope().setExceptionHandler("myFault", exceptionHandler);
    exceptionHandler = new ActionExceptionHandler();
    exceptionHandler.setFaultVariable("faultVariable2");
    action = new DroolsConsequenceAction("dialect2", "consequence2");
    exceptionHandler.setAction(action);
    process.getExceptionScope().setExceptionHandler("myFault2", exceptionHandler);
    StartNode startNode = new StartNode();
    startNode.setName("start");
    startNode.setMetaData("x", 1);
    startNode.setMetaData("y", 2);
    startNode.setMetaData("width", 3);
    startNode.setMetaData("height", 4);
    startNode.setMetaData("meta1", "someValue");
    startNode.setMetaData("meta2", "someOtherValue");
    ConstraintTrigger constraintTrigger = new ConstraintTrigger();
    constraintTrigger.setConstraint("constraint");
    Map<String, String> inMapping = new HashMap<String, String>();
    inMapping.put("key", "value");
    inMapping.put("key2", "value2");
    constraintTrigger.setInMappings(inMapping);
    startNode.addTrigger(constraintTrigger);
    EventTrigger eventTrigger = new EventTrigger();
    EventTypeFilter eventTypeFilter = new EventTypeFilter();
    eventTypeFilter.setType("eventType");
    eventTrigger.addEventFilter(eventTypeFilter);
    inMapping = new HashMap<String, String>();
    inMapping.put("key", "value");
    inMapping.put("key2", "value2");
    eventTrigger.setInMappings(inMapping);
    startNode.addTrigger(eventTrigger);
    process.addNode(startNode);
    ActionNode actionNode = new ActionNode();
    actionNode.setName("action");
    actionNode.setMetaData("x", 1);
    actionNode.setMetaData("y", 2);
    actionNode.setMetaData("width", 3);
    actionNode.setMetaData("height", 4);
    action = new DroolsConsequenceAction("dialect", "consequence");
    actionNode.setAction(action);
    process.addNode(actionNode);
    RuleSetNode ruleSetNode = new RuleSetNode();
    ruleSetNode.setName("action");
    ruleSetNode.setMetaData("x", 1);
    ruleSetNode.setMetaData("y", 2);
    ruleSetNode.setMetaData("width", 3);
    ruleSetNode.setMetaData("height", 4);
    ruleSetNode.setRuleFlowGroup("ruleFlowGroup");
    Timer timer = new Timer();
    timer.setDelay("100");
    timer.setPeriod("100");
    action = new DroolsConsequenceAction("dialect", "consequence");
    ruleSetNode.addTimer(timer, action);
    timer = new Timer();
    timer.setDelay("200");
    timer.setPeriod("200");
    action = new DroolsConsequenceAction("dialect", "consequence");
    ruleSetNode.addTimer(timer, action);
    process.addNode(ruleSetNode);
    FaultNode faultNode = new FaultNode();
    faultNode.setName("action");
    faultNode.setMetaData("x", 1);
    faultNode.setMetaData("y", 2);
    faultNode.setMetaData("width", 3);
    faultNode.setMetaData("height", 4);
    faultNode.setFaultName("faultName");
    faultNode.setFaultVariable("faultVariable");
    process.addNode(faultNode);
    Split split = new Split();
    split.setName("split");
    split.setMetaData("x", 1);
    split.setMetaData("y", 2);
    split.setMetaData("width", 3);
    split.setMetaData("height", 4);
    split.setType(Split.TYPE_XOR);
    Connection connection = new ConnectionImpl(split, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE);
    Constraint constraint = new ConstraintImpl();
    constraint.setName("constraint1 ><&&");
    constraint.setPriority(1);
    constraint.setDialect("dialect1");
    constraint.setType("type1");
    constraint.setConstraint("constraint-text1");
    split.setConstraint(connection, constraint);
    connection = new ConnectionImpl(split, Node.CONNECTION_DEFAULT_TYPE, ruleSetNode, Node.CONNECTION_DEFAULT_TYPE);
    constraint = new ConstraintImpl();
    constraint.setName("constraint2");
    constraint.setPriority(2);
    constraint.setDialect("dialect2");
    constraint.setType("type2");
    constraint.setConstraint("constraint-text2");
    split.setConstraint(connection, constraint);
    process.addNode(split);
    new ConnectionImpl(startNode, Node.CONNECTION_DEFAULT_TYPE, split, Node.CONNECTION_DEFAULT_TYPE);
    EventNode eventNode = new EventNode();
    eventNode.setName("action");
    eventNode.setMetaData("x", 1);
    eventNode.setMetaData("y", 2);
    eventNode.setMetaData("width", 3);
    eventNode.setMetaData("height", 4);
    eventNode.setVariableName("eventVariable");
    EventTypeFilter eventFilter = new EventTypeFilter();
    eventFilter.setType("eventType");
    eventNode.addEventFilter(eventFilter);
    process.addNode(eventNode);
    Join join = new Join();
    join.setName("join");
    join.setMetaData("x", 1);
    join.setMetaData("y", 2);
    join.setMetaData("width", 3);
    join.setMetaData("height", 4);
    join.setType(Join.TYPE_N_OF_M);
    join.setN("#{var1}");
    process.addNode(join);
    new ConnectionImpl(actionNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
    new ConnectionImpl(ruleSetNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
    new ConnectionImpl(eventNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
    MilestoneNode milestone = new MilestoneNode();
    milestone.setName("milestone");
    milestone.setMetaData("x", 1);
    milestone.setMetaData("y", 2);
    milestone.setMetaData("width", 3);
    milestone.setMetaData("height", 4);
    milestone.setConstraint("constraint");
    timer = new Timer();
    timer.setDelay("100");
    timer.setPeriod("100");
    action = new DroolsConsequenceAction("dialect", "consequence");
    milestone.addTimer(timer, action);
    timer = new Timer();
    timer.setDelay("200");
    timer.setPeriod("200");
    action = new DroolsConsequenceAction("dialect", "consequence");
    milestone.addTimer(timer, action);
    List<DroolsAction> actions = new ArrayList<DroolsAction>();
    DroolsAction action1 = new DroolsConsequenceAction("java", "System.out.println(\"action1\");");
    actions.add(action1);
    DroolsAction action2 = new DroolsConsequenceAction("java", "System.out.println(\"action2\");");
    actions.add(action2);
    milestone.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
    milestone.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
    process.addNode(milestone);
    connection = new ConnectionImpl(join, Node.CONNECTION_DEFAULT_TYPE, milestone, Node.CONNECTION_DEFAULT_TYPE);
    connection.setMetaData("bendpoints", "[10,10;20,20]");
    SubProcessNode subProcess = new SubProcessNode();
    subProcess.setName("subProcess");
    subProcess.setMetaData("x", 1);
    subProcess.setMetaData("y", 2);
    subProcess.setMetaData("width", 3);
    subProcess.setMetaData("height", 4);
    subProcess.setProcessId("processId");
    subProcess.setWaitForCompletion(false);
    subProcess.setIndependent(false);
    subProcess.addInMapping("subvar1", "var1");
    subProcess.addOutMapping("subvar2", "var2");
    timer = new Timer();
    timer.setDelay("100");
    timer.setPeriod("100");
    action = new DroolsConsequenceAction("dialect", "consequence");
    subProcess.addTimer(timer, action);
    timer = new Timer();
    timer.setDelay("200");
    timer.setPeriod("200");
    action = new DroolsConsequenceAction("dialect", "consequence");
    subProcess.addTimer(timer, action);
    subProcess.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
    subProcess.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
    process.addNode(subProcess);
    connection = new ConnectionImpl(milestone, Node.CONNECTION_DEFAULT_TYPE, subProcess, Node.CONNECTION_DEFAULT_TYPE);
    connection.setMetaData("bendpoints", "[10,10]");
    WorkItemNode workItemNode = new WorkItemNode();
    workItemNode.setName("WorkItem");
    Work work = new WorkImpl();
    work.setName("workname");
    Set<ParameterDefinition> parameterDefinitions = new HashSet<ParameterDefinition>();
    ParameterDefinition parameterDefinition = new ParameterDefinitionImpl("param1", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("param2", new IntegerDataType());
    parameterDefinitions.add(parameterDefinition);
    work.setParameterDefinitions(parameterDefinitions);
    work.setParameter("param1", "value1");
    work.setParameter("param2", 1);
    workItemNode.setWork(work);
    workItemNode.setWaitForCompletion(false);
    workItemNode.addInMapping("param1", "var1");
    workItemNode.addOutMapping("param2", "var2");
    timer = new Timer();
    timer.setDelay("100");
    timer.setPeriod("100");
    action = new DroolsConsequenceAction("dialect", "consequence");
    workItemNode.addTimer(timer, action);
    timer = new Timer();
    timer.setDelay("200");
    timer.setPeriod("200");
    action = new DroolsConsequenceAction("dialect", "consequence");
    workItemNode.addTimer(timer, action);
    workItemNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
    workItemNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
    process.addNode(workItemNode);
    connection = new ConnectionImpl(subProcess, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE);
    connection.setMetaData("bendpoints", "[]");
    HumanTaskNode humanTaskNode = new HumanTaskNode();
    humanTaskNode.setName("Human Task");
    work = humanTaskNode.getWork();
    parameterDefinitions = new HashSet<ParameterDefinition>();
    parameterDefinition = new ParameterDefinitionImpl("TaskName", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("ActorId", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("Priority", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    parameterDefinition = new ParameterDefinitionImpl("Comment", new StringDataType());
    parameterDefinitions.add(parameterDefinition);
    work.setParameterDefinitions(parameterDefinitions);
    work.setParameter("TaskName", "Do something");
    work.setParameter("ActorId", "John Doe");
    humanTaskNode.setWaitForCompletion(false);
    humanTaskNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
    humanTaskNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
    process.addNode(humanTaskNode);
    connection = new ConnectionImpl(workItemNode, Node.CONNECTION_DEFAULT_TYPE, humanTaskNode, Node.CONNECTION_DEFAULT_TYPE);
    TimerNode timerNode = new TimerNode();
    timerNode.setName("timer");
    timerNode.setMetaData("x", 1);
    timerNode.setMetaData("y", 2);
    timerNode.setMetaData("width", 3);
    timerNode.setMetaData("height", 4);
    timer = new Timer();
    timer.setDelay("1000");
    timer.setPeriod("1000");
    timerNode.setTimer(timer);
    process.addNode(timerNode);
    new ConnectionImpl(humanTaskNode, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE);
    ForEachNode forEachNode = new ForEachNode();
    forEachNode.setName("ForEach");
    forEachNode.setCollectionExpression("collection");
    forEachNode.setVariable("variableName", new ObjectDataType());
    forEachNode.setWaitForCompletion(false);
    ActionNode subActionNode1 = new ActionNode();
    forEachNode.getCompositeNode().addNode(subActionNode1);
    ActionNode subActionNode2 = new ActionNode();
    forEachNode.getCompositeNode().addNode(subActionNode2);
    new ConnectionImpl(subActionNode1, Node.CONNECTION_DEFAULT_TYPE, subActionNode2, Node.CONNECTION_DEFAULT_TYPE);
    forEachNode.getCompositeNode().linkIncomingConnections(Node.CONNECTION_DEFAULT_TYPE, subActionNode1.getId(), Node.CONNECTION_DEFAULT_TYPE);
    forEachNode.getCompositeNode().linkOutgoingConnections(subActionNode2.getId(), Node.CONNECTION_DEFAULT_TYPE, Node.CONNECTION_DEFAULT_TYPE);
    process.addNode(forEachNode);
    new ConnectionImpl(timerNode, Node.CONNECTION_DEFAULT_TYPE, forEachNode, Node.CONNECTION_DEFAULT_TYPE);
    CompositeContextNode compositeNode = new CompositeContextNode();
    compositeNode.setName("Composite");
    VariableScope variableScope = new VariableScope();
    compositeNode.addContext(variableScope);
    compositeNode.setDefaultContext(variableScope);
    variableScope.setVariables(variables);
    ExceptionScope exceptionScope = new ExceptionScope();
    compositeNode.addContext(exceptionScope);
    compositeNode.setDefaultContext(exceptionScope);
    exceptionHandler = new ActionExceptionHandler();
    exceptionHandler.setFaultVariable("faultVariable");
    action = new DroolsConsequenceAction("dialect", "consequence");
    exceptionHandler.setAction(action);
    exceptionScope.setExceptionHandler("MyFault", exceptionHandler);
    exceptionHandler = new ActionExceptionHandler();
    exceptionHandler.setFaultVariable("faultVariable2");
    action = new DroolsConsequenceAction("dialect2", "consequence2");
    exceptionHandler.setAction(action);
    exceptionScope.setExceptionHandler("MyFault2", exceptionHandler);
    subActionNode1 = new ActionNode();
    compositeNode.addNode(subActionNode1);
    subActionNode2 = new ActionNode();
    compositeNode.addNode(subActionNode2);
    new ConnectionImpl(subActionNode1, Node.CONNECTION_DEFAULT_TYPE, subActionNode2, Node.CONNECTION_DEFAULT_TYPE);
    compositeNode.linkIncomingConnections(Node.CONNECTION_DEFAULT_TYPE, subActionNode1.getId(), Node.CONNECTION_DEFAULT_TYPE);
    compositeNode.linkOutgoingConnections(subActionNode2.getId(), Node.CONNECTION_DEFAULT_TYPE, Node.CONNECTION_DEFAULT_TYPE);
    process.addNode(compositeNode);
    new ConnectionImpl(forEachNode, Node.CONNECTION_DEFAULT_TYPE, compositeNode, Node.CONNECTION_DEFAULT_TYPE);
    EndNode endNode = new EndNode();
    endNode.setName("end");
    endNode.setTerminate(false);
    endNode.setMetaData("x", 1);
    endNode.setMetaData("y", 2);
    endNode.setMetaData("width", 3);
    endNode.setMetaData("height", 4);
    process.addNode(endNode);
    StateNode stateNode = new StateNode();
    stateNode.setName("state");
    stateNode.setMetaData("x", 1);
    stateNode.setMetaData("y", 2);
    stateNode.setMetaData("width", 3);
    stateNode.setMetaData("height", 4);
    timer = new Timer();
    timer.setDelay("100");
    timer.setPeriod("100");
    action = new DroolsConsequenceAction("dialect", "consequence");
    stateNode.addTimer(timer, action);
    timer = new Timer();
    timer.setDelay("200");
    timer.setPeriod("200");
    action = new DroolsConsequenceAction("dialect", "consequence");
    stateNode.addTimer(timer, action);
    actions = new ArrayList<DroolsAction>();
    action1 = new DroolsConsequenceAction("java", "System.out.println(\"action1\");");
    actions.add(action1);
    action2 = new DroolsConsequenceAction("java", "System.out.println(\"action2\");");
    actions.add(action2);
    stateNode.setActions(ExtendedNodeImpl.EVENT_NODE_ENTER, actions);
    stateNode.setActions(ExtendedNodeImpl.EVENT_NODE_EXIT, actions);
    new ConnectionImpl(compositeNode, Node.CONNECTION_DEFAULT_TYPE, stateNode, Node.CONNECTION_DEFAULT_TYPE);
    connection = new ConnectionImpl(stateNode, Node.CONNECTION_DEFAULT_TYPE, join, Node.CONNECTION_DEFAULT_TYPE);
    constraint = new ConstraintImpl();
    constraint.setName("constraint1 ><&&");
    constraint.setPriority(1);
    constraint.setDialect("dialect1");
    constraint.setType("type1");
    constraint.setConstraint("constraint-text1 %&<>");
    stateNode.setConstraint(connection, constraint);
    connection = new ConnectionImpl(stateNode, Node.CONNECTION_DEFAULT_TYPE, endNode, Node.CONNECTION_DEFAULT_TYPE);
    constraint = new ConstraintImpl();
    constraint.setName("constraint2");
    constraint.setPriority(2);
    constraint.setDialect("dialect2");
    constraint.setType("type2");
    constraint.setConstraint("constraint-text2");
    stateNode.setConstraint(connection, constraint);
    process.addNode(stateNode);
    String xml = XmlRuleFlowProcessDumper.INSTANCE.dump(process, true);
    if (xml == null) {
        throw new IllegalArgumentException("Failed to persist full nodes!");
    }
    SemanticModules modules = new SemanticModules();
    modules.addSemanticModule(new ProcessSemanticModule());
    XmlProcessReader reader = new XmlProcessReader(modules, getClass().getClassLoader());
    List<Process> processes = reader.read(new StringReader(xml));
    assertNotNull(processes);
    process = (RuleFlowProcess) processes.get(0);
    if (process == null) {
        throw new IllegalArgumentException("Failed to reload process!");
    }
    assertEquals(16, process.getNodes().length);
    assertEquals(2, process.getImports().size());
    assertEquals(2, process.getGlobals().size());
    assertEquals(4, process.getVariableScope().getVariables().size());
    assertEquals(2, process.getSwimlaneContext().getSwimlanes().size());
    assertEquals(2, process.getExceptionScope().getExceptionHandlers().size());
    String xml2 = XmlRuleFlowProcessDumper.INSTANCE.dump(process, true);
    if (xml2 == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    Document control = XMLUnit.buildDocument(XMLUnit.newControlParser(), new StringReader(xml));
    Document test = XMLUnit.buildDocument(XMLUnit.newTestParser(), new StringReader(xml2));
    Diff diff = new Diff(control, test, null, new ElementNameAndAttributeQualifier("name"));
    assertTrue(diff.toString(), diff.similar());
// test serialization of process elements
}

Example 5 with CompositeContextNode

use of org.jbpm.workflow.core.node.CompositeContextNode in project jbpm by kiegroup.

the class XMLPersistenceTest method testPersistenceOfEmptyNodes.

@Test
public void testPersistenceOfEmptyNodes() throws Exception {
    RuleFlowProcess process = new RuleFlowProcess() {

        private static final long serialVersionUID = 510l;

        int id = 0;

        public void addNode(org.kie.api.definition.process.Node node) {
            ((Node) node).setId(++id);
            super.addNode(node);
        }
    };
    process.addNode(new StartNode());
    process.addNode(new EndNode());
    process.addNode(new ActionNode());
    process.addNode(new Split());
    process.addNode(new Join());
    process.addNode(new MilestoneNode());
    process.addNode(new RuleSetNode());
    process.addNode(new SubProcessNode());
    process.addNode(new WorkItemNode());
    process.addNode(new TimerNode());
    process.addNode(new HumanTaskNode());
    process.addNode(new ForEachNode());
    process.addNode(new CompositeContextNode());
    process.addNode(new EventNode());
    process.addNode(new FaultNode());
    process.addNode(new StateNode());
    process.addNode(new DynamicNode());
    String xml = XmlRuleFlowProcessDumper.INSTANCE.dump(process, false);
    if (xml == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    SemanticModules modules = new SemanticModules();
    modules.addSemanticModule(new ProcessSemanticModule());
    XmlProcessReader reader = new XmlProcessReader(modules, getClass().getClassLoader());
    List<Process> processes = reader.read(new StringReader(xml));
    assertNotNull(processes);
    process = (RuleFlowProcess) processes.get(0);
    if (process == null) {
        throw new IllegalArgumentException("Failed to reload process!");
    }
    assertEquals(17, process.getNodes().length);
    String xml2 = XmlRuleFlowProcessDumper.INSTANCE.dump(process, false);
    if (xml2 == null) {
        throw new IllegalArgumentException("Failed to persist empty nodes!");
    }
    assertXMLEqual(xml, xml2);
// assertEquals(xml, xml2);
}