/// /// <summary> /// +-----------------+ /// | Case1 \ /// +-------------------+---+ /// | | /// | +-------+ | /// | | A | | /// | +-------+ | /// | | /// +-----------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCloseSuspendedCaseInstance() public virtual void testCloseSuspendedCaseInstance() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); // given // a case definition CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("close", stateTransitionCollector).createActivity("A").behavior(new TaskWaitState()).endActivity().buildCaseDefinition(); // an active case instance CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); caseInstance.suspend(); assertTrue(caseInstance.Suspended); // when // close case caseInstance.close(); // then IList <string> expectedStateTransitions = new List <string>(); // expected state transition: // suspended --close(Case1)--> closed expectedStateTransitions.Add("suspended --close(Case1)--> closed"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); assertTrue(caseInstance.Closed); assertNull(caseInstance.findCaseExecution("A")); }
/// /// <summary> /// +-----------------+ /// | Case1 \ /// +-------------------+-----------------+ /// | | /// | +------------------------+ | /// | / X \ | /// | + +-------+ +-------+ + | /// | | | A | | B | | | /// | + +-------+ +-------+ + | /// | \ / | /// | +------------------------+ | /// | | /// +-------------------------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCloseStage() public virtual void testCloseStage() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); // given // a case definition CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("close", stateTransitionCollector).createActivity("X").behavior(new StageActivityBehavior()).createActivity("A").behavior(new TaskWaitState()).endActivity().createActivity("B").behavior(new TaskWaitState()).endActivity().endActivity().buildCaseDefinition(); // an active case instance CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); CmmnActivityExecution stageX = caseInstance.findCaseExecution("X"); try { // when stageX.close(); fail("It should not be possible to close a stage."); } catch (CaseIllegalStateTransitionException) { } // then assertTrue(stateTransitionCollector.stateTransitions.Count == 0); assertTrue(caseInstance.Active); assertNotNull(caseInstance.findCaseExecution("X")); }
protected internal override void triggerCallableElement(CmmnActivityExecution execution, IDictionary <string, object> variables, string businessKey) { CmmnCaseDefinition definition = getCaseDefinitionToCall(execution, CallableElement); CmmnCaseInstance caseInstance = execution.createSubCaseInstance(definition, businessKey); caseInstance.create(variables); }
protected internal virtual CmmnActivity createActivity(CmmnElement element, CmmnHandlerContext context) { string id = element.Id; CmmnActivity parent = context.Parent; CmmnActivity newActivity = null; if (parent != null) { newActivity = parent.createActivity(id); } else { CmmnCaseDefinition caseDefinition = context.CaseDefinition; newActivity = new CmmnActivity(id, caseDefinition); } newActivity.CmmnElement = element; CmmnActivityBehavior behavior = ActivityBehavior; newActivity.ActivityBehavior = behavior; return(newActivity); }
public override CaseExecutionEntity createSubCaseInstance(CmmnCaseDefinition caseDefinition, string businessKey) { CaseExecutionEntity subCaseInstance = (CaseExecutionEntity)caseDefinition.createCaseInstance(businessKey); // inherit the tenant-id from the case definition string tenantId = ((CaseDefinitionEntity)caseDefinition).TenantId; if (!string.ReferenceEquals(tenantId, null)) { subCaseInstance.TenantId = tenantId; } else { // if case definition has no tenant id, inherit this case instance's tenant id subCaseInstance.TenantId = this.tenantId; } // manage bidirectional super-sub-case-instances relation subCaseInstance.SuperCaseExecution = this; setSubCaseInstance(subCaseInstance); fireHistoricCaseActivityInstanceUpdate(); return(subCaseInstance); }
protected internal virtual void ensureCaseDefinitionInitialized() { if ((caseDefinition == null) && (!string.ReferenceEquals(caseDefinitionId, null))) { CaseDefinitionEntity deployedCaseDefinition = Context.ProcessEngineConfiguration.DeploymentCache.getCaseDefinitionById(caseDefinitionId); CaseDefinition = deployedCaseDefinition; } }
public override CaseExecutionImpl createSubCaseInstance(CmmnCaseDefinition caseDefinition, string businessKey) { CaseExecutionImpl caseInstance = (CaseExecutionImpl)caseDefinition.createCaseInstance(businessKey); // manage bidirectional super-sub-case-instances relation subCaseInstance.setSuperCaseExecution(this); setSubCaseInstance(subCaseInstance); return(caseInstance); }
/// /// <summary> /// +-----------------+ /// | Case1 \ /// +-------------------+---+ /// | | /// | +-------+ | /// | | A | | /// | +-------+ | /// | | /// +-----------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCaseInstanceWithOneTask() public virtual void testCaseInstanceWithOneTask() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("create", stateTransitionCollector).createActivity("A").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().buildCaseDefinition(); // create a new case instance CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); // expected state transitions after creation of a case instance: // () --create(Case1)--> active // () --create(A)--> available // available --enable(A)--> enabled IList <string> expectedStateTransitions = new List <string>(); expectedStateTransitions.Add("() --create(Case1)--> active"); expectedStateTransitions.Add("() --create(A)--> available"); expectedStateTransitions.Add("available --enable(A)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // case instance is active assertTrue(caseInstance.Active); CaseExecutionImpl instance = (CaseExecutionImpl)caseInstance; // case instance has one child plan item IList <CaseExecutionImpl> childPlanItems = instance.CaseExecutions; assertEquals(1, childPlanItems.Count); CaseExecutionImpl planItemA = childPlanItems[0]; // the child plan item is enabled assertTrue(planItemA.Enabled); // the parent of the child plan item is the case instance assertEquals(caseInstance, planItemA.getParent()); // manual start of A planItemA.manualStart(); // expected state transition after manual start of A: // enabled --enable(A)--> active expectedStateTransitions.Add("enabled --manualStart(A)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); assertTrue(planItemA.Active); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testWithParent() public virtual void testWithParent() { // given CmmnCaseDefinition parent = new CmmnCaseDefinition("aParentActivity"); context.Parent = parent; // when CmmnActivity activity = handler.handleElement(planItem, context); // then assertEquals(parent, activity.Parent); assertTrue(parent.Activities.Contains(activity)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCaseInstanceWithOneStateWithoutManualStartOfChildren() public virtual void testCaseInstanceWithOneStateWithoutManualStartOfChildren() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("create", stateTransitionCollector).createActivity("X").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new StageActivityBehavior()).createActivity("A").listener("create", stateTransitionCollector).listener("start", stateTransitionCollector).behavior(new TaskWaitState()).endActivity().createActivity("B").listener("create", stateTransitionCollector).listener("start", stateTransitionCollector).behavior(new TaskWaitState()).endActivity().endActivity().buildCaseDefinition(); CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); IList <string> expectedStateTransitions = initAndAssertExpectedTransitions(stateTransitionCollector); emptyCollector(stateTransitionCollector, expectedStateTransitions); // clear lists CaseExecutionImpl planItemX = assertCaseXState(caseInstance); // manual start of x planItemX.manualStart(); // X should be active assertTrue(planItemX.Active); // expected state transitions after a manual start of X: expectedStateTransitions.Add("enabled --manualStart(X)--> active"); expectedStateTransitions.Add("() --create(A)--> available"); expectedStateTransitions.Add("available --start(A)--> active"); expectedStateTransitions.Add("() --create(B)--> available"); expectedStateTransitions.Add("available --start(B)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // X should have two chil plan items IList <CaseExecutionImpl> childPlanItems; childPlanItems = planItemX.CaseExecutions; assertEquals(2, childPlanItems.Count); foreach (CmmnExecution childPlanItem in childPlanItems) { // both children should be active assertTrue(childPlanItem.Active); // X should be the parent of both children assertEquals(planItemX, childPlanItem.Parent); } }
protected internal virtual void transformCaseDefinitions() { Definitions definitions = model.Definitions; ICollection <Case> cases = definitions.Cases; foreach (Case currentCase in cases) { context.CaseDefinition = null; context.Parent = null; CmmnCaseDefinition caseDefinition = transformCase(currentCase); caseDefinitions.Add((CaseDefinitionEntity)caseDefinition); } }
/// /// <summary> /// +-----------------+ +-----------------+ /// | Case1 \ | aCaseDefinition | /// +-------------------+---+ +-----------------+ /// | | | /// | | ==> +-----------------+ /// | | | aCasePlanModel | /// | | +-----------------+ /// | | /// +-----------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCasePlanModel() public virtual void testCasePlanModel() { // given // when IList <CaseDefinitionEntity> caseDefinitions = transform(); // then assertEquals(1, caseDefinitions.Count); CmmnCaseDefinition caseModel = caseDefinitions[0]; IList <CmmnActivity> activities = caseModel.Activities; assertEquals(1, activities.Count); CmmnActivity casePlanModelActivity = activities[0]; assertEquals(casePlanModel.Id, casePlanModelActivity.Id); assertTrue(casePlanModelActivity.Activities.Count == 0); }
/// /// <summary> /// +-----------------+ /// | Case1 \ /// +-------------------+---+ /// | | /// | +-------+ | /// | | A | | /// | +-------+ | /// | | /// +-----------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testCloseCompletedCaseInstance() public virtual void testCloseCompletedCaseInstance() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); // given // a case definition CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("close", stateTransitionCollector).createActivity("A").behavior(new TaskWaitState()).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).endActivity().buildCaseDefinition(); // an active case instance CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); // task A as a child of the case instance CmmnActivityExecution taskA = caseInstance.findCaseExecution("A"); // disable task A -> completes case instance taskA.disable(); assertTrue(caseInstance.Completed); // when // close case caseInstance.close(); // then IList <string> expectedStateTransitions = new List <string>(); // expected state transition: // completed --close(Case1)--> closed expectedStateTransitions.Add("completed --close(Case1)--> closed"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); assertTrue(caseInstance.Closed); }
public virtual void transformCase(Case element, CmmnCaseDefinition caseDefinition) { modelElementInstances.Add(element); cmmnActivities.Add(caseDefinition); }
/// /// <summary> /// +-----------------+ /// | Case1 \ /// +-------------------+-------------------+ /// | | /// | +-------+ | /// | | A1 | | /// | +-------+ | /// | | /// | +------------------------+ | /// | / X1 \ | /// | + +-------+ +-------+ + | /// | | | A2 | | B1 | | | /// | + +-------+ +-------+ + | /// | \ / | /// | +------------------------+ | /// | | /// | +-----------------------------+ | /// | / Y \ | /// | + +-------+ + | /// | | | C | | | /// | | +-------+ | | /// | | | | /// | | +------------------------+ | | /// | | / X2 \ | | /// | | + +-------+ +-------+ + | | /// | | | | A3 | | B2 | | | | /// | | + +-------+ +-------+ + | | /// | | \ / | | /// | + +------------------------+ + | /// | \ / | /// | +-----------------------------+ | /// | | /// +---------------------------------------+ /// /// </summary> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testStartComplexCaseInstance() public virtual void testStartComplexCaseInstance() { CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector(); CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("create", stateTransitionCollector).createActivity("A1").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().createActivity("X1").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new StageActivityBehavior()).createActivity("A2").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().createActivity("B1").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().endActivity().createActivity("Y").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new StageActivityBehavior()).createActivity("C").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().createActivity("X2").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new StageActivityBehavior()).createActivity("A3").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().createActivity("B2").listener("create", stateTransitionCollector).listener("enable", stateTransitionCollector).listener("manualStart", stateTransitionCollector).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).behavior(new TaskWaitState()).endActivity().endActivity().endActivity().buildCaseDefinition(); CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance(); caseInstance.create(); // expected state transitions after the creation of a case instance: // () --create(Case1)--> active // () --create(A1)--> available // available --enable(A1)--> enabled // () --create(X1)--> available // available --enable(X1)--> enabled // () --create(Y)--> available // available --enable(Y)--> enabled IList <string> expectedStateTransitions = new List <string>(); expectedStateTransitions.Add("() --create(Case1)--> active"); expectedStateTransitions.Add("() --create(A1)--> available"); expectedStateTransitions.Add("available --enable(A1)--> enabled"); expectedStateTransitions.Add("() --create(X1)--> available"); expectedStateTransitions.Add("available --enable(X1)--> enabled"); expectedStateTransitions.Add("() --create(Y)--> available"); expectedStateTransitions.Add("available --enable(Y)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); CaseExecutionImpl instance = (CaseExecutionImpl)caseInstance; // the case instance should be active assertTrue(instance.Active); // the case instance should have three child plan items (A1, X1, Y) IList <CaseExecutionImpl> childPlanItems = instance.CaseExecutions; assertEquals(3, childPlanItems.Count); // handle plan item A1 ////////////////////////////////////////////////// CaseExecutionImpl planItemA1 = (CaseExecutionImpl)instance.findCaseExecution("A1"); // case instance should be the parent of A1 assertEquals(caseInstance, planItemA1.getParent()); // A1 should be enabled assertTrue(planItemA1.Enabled); // manual start of A1 planItemA1.manualStart(); // A1 should be active assertTrue(planItemA1.Active); // expected state transitions: // enabled --manualStart(A1)--> active expectedStateTransitions.Add("enabled --manualStart(A1)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item X1 /////////////////////////////////////////////////// CaseExecutionImpl planItemX1 = (CaseExecutionImpl)instance.findCaseExecution("X1"); // case instance should be the parent of X1 assertEquals(caseInstance, planItemX1.getParent()); // X1 should be enabled assertTrue(planItemX1.Enabled); // manual start of X1 planItemX1.manualStart(); // X1 should be active assertTrue(planItemX1.Active); // X1 should have two children childPlanItems = planItemX1.CaseExecutions; assertEquals(2, childPlanItems.Count); // expected state transitions after manual start of X1: // enabled --manualStart(X1)--> active // () --create(A2)--> available // available --enable(A2)--> enabled // () --create(B1)--> available // available --enable(B1)--> enabled expectedStateTransitions.Add("enabled --manualStart(X1)--> active"); expectedStateTransitions.Add("() --create(A2)--> available"); expectedStateTransitions.Add("available --enable(A2)--> enabled"); expectedStateTransitions.Add("() --create(B1)--> available"); expectedStateTransitions.Add("available --enable(B1)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item A2 //////////////////////////////////////////////// CaseExecutionImpl planItemA2 = (CaseExecutionImpl)instance.findCaseExecution("A2"); // X1 should be the parent of A2 assertEquals(planItemX1, planItemA2.getParent()); // A2 should be enabled assertTrue(planItemA2.Enabled); // manual start of A2 planItemA2.manualStart(); // A2 should be active assertTrue(planItemA2.Active); // expected state transition after manual start of A2: // enabled --manualStart(A2)--> active expectedStateTransitions.Add("enabled --manualStart(A2)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item B1 ///////////////////////////////////////////////// CaseExecutionImpl planItemB1 = (CaseExecutionImpl)instance.findCaseExecution("B1"); // X1 should be the parent of B1 assertEquals(planItemX1, planItemB1.getParent()); // B1 should be enabled assertTrue(planItemB1.Enabled); // manual start of B1 planItemB1.manualStart(); // B1 should be active assertTrue(planItemB1.Active); // expected state transition after manual start of B1: // enabled --manualStart(B1)--> active expectedStateTransitions.Add("enabled --manualStart(B1)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item Y //////////////////////////////////////////////// CaseExecutionImpl planItemY = (CaseExecutionImpl)instance.findCaseExecution("Y"); // case instance should be the parent of Y assertEquals(caseInstance, planItemY.getParent()); // Y should be enabled assertTrue(planItemY.Enabled); // manual start of Y planItemY.manualStart(); // Y should be active assertTrue(planItemY.Active); // Y should have two children childPlanItems = planItemY.CaseExecutions; assertEquals(2, childPlanItems.Count); // expected state transitions after manual start of Y: // enabled --manualStart(Y)--> active // () --create(C)--> available // available --enable(C)--> enabled // () --create(X2)--> available // available --enable(X2)--> enabled expectedStateTransitions.Add("enabled --manualStart(Y)--> active"); expectedStateTransitions.Add("() --create(C)--> available"); expectedStateTransitions.Add("available --enable(C)--> enabled"); expectedStateTransitions.Add("() --create(X2)--> available"); expectedStateTransitions.Add("available --enable(X2)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item C ////////////////////////////////////////////////// CaseExecutionImpl planItemC = (CaseExecutionImpl)instance.findCaseExecution("C"); // Y should be the parent of C assertEquals(planItemY, planItemC.getParent()); // C should be enabled assertTrue(planItemC.Enabled); // manual start of C planItemC.manualStart(); // C should be active assertTrue(planItemC.Active); // expected state transition after manual start of C: // enabled --manualStart(C)--> active expectedStateTransitions.Add("enabled --manualStart(C)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item X2 /////////////////////////////////////////// CaseExecutionImpl planItemX2 = (CaseExecutionImpl)instance.findCaseExecution("X2"); // Y should be the parent of X2 assertEquals(planItemY, planItemX2.getParent()); // X2 should be enabled assertTrue(planItemX2.Enabled); // manual start of X2 planItemX2.manualStart(); // X2 should be active assertTrue(planItemX2.Active); // X2 should have two children childPlanItems = planItemX2.CaseExecutions; assertEquals(2, childPlanItems.Count); // expected state transitions after manual start of X2: // enabled --manualStart(X2)--> active // () --create(A3)--> available // available --enable(A3)--> enabled // () --create(B2)--> available // available --enable(B2)--> enabled expectedStateTransitions.Add("enabled --manualStart(X2)--> active"); expectedStateTransitions.Add("() --create(A3)--> available"); expectedStateTransitions.Add("available --enable(A3)--> enabled"); expectedStateTransitions.Add("() --create(B2)--> available"); expectedStateTransitions.Add("available --enable(B2)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item A3 ////////////////////////////////////////////// CaseExecutionImpl planItemA3 = (CaseExecutionImpl)instance.findCaseExecution("A3"); // A3 should be the parent of X2 assertEquals(planItemX2, planItemA3.getParent()); // A3 should be enabled assertTrue(planItemA3.Enabled); // manual start of A3 planItemA3.manualStart(); // A3 should be active assertTrue(planItemA3.Active); // expected state transition after manual start of A3: // enabled --manualStart(A3)--> active expectedStateTransitions.Add("enabled --manualStart(A3)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); // handle plan item B2 ///////////////////////////////////////////////// CaseExecutionImpl planItemB2 = (CaseExecutionImpl)instance.findCaseExecution("B2"); // B2 should be the parent of X2 assertEquals(planItemX2, planItemB2.getParent()); // B2 should be enabled assertTrue(planItemB2.Enabled); // manual start of B2 planItemB2.manualStart(); // B2 should be active assertTrue(planItemB2.Active); // expected state transition after manual start of B2: // enabled --manualStart(B2)--> active expectedStateTransitions.Add("enabled --manualStart(B2)--> active"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); // clear lists emptyCollector(stateTransitionCollector, expectedStateTransitions); }
public virtual void transformCase(Case element, CmmnCaseDefinition caseDefinition) { }
public override CaseExecutionImpl createSubCaseInstance(CmmnCaseDefinition caseDefinition) { return(createSubCaseInstance(caseDefinition, null)); }