/// /// <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")); }
/// /// <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 \ /// +-------------------+---+ /// | | /// | +-------+ | /// | | 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 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 IList <string> initAndAssertExpectedTransitions(CaseExecutionStateTransitionCollector stateTransitionCollector) { // expected state transitions after the creation of a case instance: // () --create(Case1)--> active // () --create(X)--> available // available --enable(X)--> enabled IList <string> expectedStateTransitions = new List <string>(); expectedStateTransitions.Add("() --create(Case1)--> active"); expectedStateTransitions.Add("() --create(X)--> available"); expectedStateTransitions.Add("available --enable(X)--> enabled"); assertEquals(expectedStateTransitions, stateTransitionCollector.stateTransitions); return(expectedStateTransitions); }
/// /// <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); }
/// /// <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); }
protected internal virtual void emptyCollector(CaseExecutionStateTransitionCollector stateTransitionCollector, IList <string> expectedStateTransitions) { // clear lists expectedStateTransitions.Clear(); stateTransitionCollector.stateTransitions.Clear(); }