//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableInOutMappingOfCallActivity()
public virtual void testNonInterruptingSetVariableInOutMappingOfCallActivity()
{
engine.manageDeployment(repositoryService.createDeployment().addModelInstance(CONDITIONAL_MODEL, DELEGATED_PROCESS).deploy());
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().callActivity(TASK_WITH_CONDITION_ID).calledElement(DELEGATED_PROCESS_KEY).camundaOut(VARIABLE_NAME, VARIABLE_NAME).userTask().name(TASK_AFTER_OUTPUT_MAPPING).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, false);
modelInstance = addBoundaryEvent(modelInstance, TASK_WITH_CONDITION_ID, TASK_AFTER_COND_BOUN_EVENT_IN_SUB_PROCESS, false);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
Task task = taskQuery.singleResult();
assertNotNull(task);
assertEquals(TASK_BEFORE_CONDITION, task.Name);
//when task before service task is completed
taskService.complete(task.Id);
//then out mapping of call activity sets a variable
//-> all non interrupting conditional events are triggered
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(5, tasksAfterVariableIsSet.Count);
//three subscriptions: event sub process in sub process and on process instance level and boundary event of sub process
assertEquals(3, conditionEventSubscriptionQuery.count());
}
protected internal virtual void testDelegation()
{
TaskQuery taskQuery = taskService.createTaskQuery();
//when
Task taskInSubProcess = taskQuery.singleResult();
assertEquals("Task in subprocess", taskInSubProcess.Name);
//then check value from input variable
object inputVar = runtimeService.getVariable(taskInSubProcess.ProcessInstanceId, "TestInputVar");
assertEquals("inValue", inputVar);
//when completing the task in the subprocess, finishes the subprocess
taskService.complete(taskInSubProcess.Id);
Task taskAfterSubProcess = taskQuery.singleResult();
assertEquals("Task after subprocess", taskAfterSubProcess.Name);
//then check value from output variable
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().singleResult();
object outputVar = runtimeService.getVariable(processInstance.Id, "TestOutputVar");
assertEquals("outValue", outputVar);
//complete task after sub process
taskService.complete(taskAfterSubProcess.Id);
}
public virtual void testCallActivityByExpression()
{
// Start process (main)
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testCallActivityByExpression");
// one task in the subprocess should be active after starting the process instance
TaskQuery taskQuery = taskService.createTaskQuery();
Task taskBeforeSubProcess = taskQuery.singleResult();
assertEquals("Task before subprocess", taskBeforeSubProcess.Name);
// Completing the task continues the process which leads to calling the subprocess. The sub process we want to
// call is passed in as a variable into this task
taskService.complete(taskBeforeSubProcess.Id);
Task taskInSubProcess = taskQuery.singleResult();
assertEquals("Task in subprocess", taskInSubProcess.Name);
// Completing the task in the subprocess, finishes the subprocess
taskService.complete(taskInSubProcess.Id);
Task taskAfterSubProcess = taskQuery.singleResult();
assertEquals("Task after subprocess", taskAfterSubProcess.Name);
// Completing this task end the process instance
taskService.complete(taskAfterSubProcess.Id);
assertProcessEnded(processInstance.Id);
}
public virtual void testCompleteProcessWithCallActivityAndOneCompletedTask()
{
//given process after multi-instance callactivity
ProcessInstance processInstance = rule.processInstance();
TaskQuery taskQuery = rule.TaskService.createTaskQuery().processInstanceId(processInstance.Id);
Task taskAfterSubProcess = taskQuery.taskName("Task after multi-instance").singleResult();
assertNotNull(taskAfterSubProcess);
// Completing this task end the process instance
rule.TaskService.complete(taskAfterSubProcess.Id);
rule.assertScenarioEnded();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendProcessInstanceIncludingUserTaskForNonTenant()
public virtual void suspendProcessInstanceIncludingUserTaskForNonTenant()
{
// given activated user tasks
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).processDefinitionWithoutTenantId().suspend();
assertThat(query.active().count(), @is(2L));
assertThat(query.suspended().count(), @is(1L));
assertThat(query.suspended().withoutTenantId().count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageByProcessDefinitionIdWithAuthenticatedTenant()
public virtual void correlateMessageByProcessDefinitionIdWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_START_PROCESS);
ProcessDefinition processDefinition = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("messageStart").singleResult();
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.createMessageCorrelation("message").processDefinitionId(processDefinition.Id).correlateStartMessage();
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageByProcessInstanceIdWithAuthenticatedTenant()
public virtual void correlateMessageByProcessInstanceIdWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS);
ProcessInstance processInstance = engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").execute();
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.createMessageCorrelation("message").processInstanceId(processInstance.Id).correlate();
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
// sub process testing with event sub process on process instance and in sub process /////////////////////////////////
// and conditional start event and boundary event on sub process /////////////////////////////////////////////////////
// execution listener in sub process /////////////////////////////////////////////////////////////////////////////////
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSetVariableOnStartExecutionListenerInSubProcessWithBoundary()
public virtual void testSetVariableOnStartExecutionListenerInSubProcessWithBoundary()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).camundaExecutionListenerExpression([email protected]_Fields.EVENTNAME_START, EXPR_SET_VARIABLE).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, true);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, true);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when start listener sets variable
//then conditional boundary should not triggered but conditional start event
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(TASK_AFTER_CONDITIONAL_START_EVENT, tasksAfterVariableIsSet[0].Name);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableOnOutputMappingInSubProcessWithBoundary()
public virtual void testNonInterruptingSetVariableOnOutputMappingInSubProcessWithBoundary()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).camundaOutputParameter(VARIABLE_NAME, "1").name(TASK_WITH_CONDITION).userTask().name(TASK_AFTER_OUTPUT_MAPPING).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, false);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when task before is completed
taskService.complete(taskQuery.singleResult().Id);
//then all conditional events are triggered
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(4, tasksAfterVariableIsSet.Count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void signalIntermediateCatchEventWithAuthenticatedTenant()
public virtual void signalIntermediateCatchEventWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, SIGNAL_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("signalCatch").processDefinitionTenantId(TENANT_ONE).execute();
Execution execution = engineRule.RuntimeService.createExecutionQuery().processDefinitionKey("signalCatch").signalEventSubscriptionName("signal").singleResult();
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.signal(execution.Id, "signal", null, null);
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sendSignalToStartAndIntermediateCatchEventDisabledTenantCheck()
public virtual void sendSignalToStartAndIntermediateCatchEventDisabledTenantCheck()
{
testRule.deployForTenant(TENANT_ONE, SIGNAL_START_PROCESS, SIGNAL_CATCH_PROCESS);
testRule.deployForTenant(TENANT_TWO, SIGNAL_START_PROCESS, SIGNAL_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("signalCatch").processDefinitionTenantId(TENANT_ONE).execute();
engineRule.RuntimeService.createProcessInstanceByKey("signalCatch").processDefinitionTenantId(TENANT_TWO).execute();
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.createSignalEvent("signal").send();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(4L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(2L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableOnStartExecutionListenerInSubProcessWithBoundary()
public virtual void testNonInterruptingSetVariableOnStartExecutionListenerInSubProcessWithBoundary()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).camundaExecutionListenerExpression([email protected]_Fields.EVENTNAME_START, EXPR_SET_VARIABLE).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, false);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when start listener sets variable
//then conditional boundary and event sub process inside the sub process should triggered via default evaluation behavior
//and global conditional start event via delayed events
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(4, tasksAfterVariableIsSet.Count);
assertTaskNames(tasksAfterVariableIsSet, TASK_AFTER_CONDITIONAL_START_EVENT, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, TASK_AFTER_CONDITIONAL_BOUNDARY_EVENT, TASK_WITH_CONDITION);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateReceivedMessageToIntermediateCatchEventWithAuthenticatedTenant()
public virtual void correlateReceivedMessageToIntermediateCatchEventWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").execute();
Execution execution = engineRule.RuntimeService.createExecutionQuery().processDefinitionKey("messageCatch").messageEventSubscriptionName("message").singleResult();
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.messageEventReceived("message", execution.Id);
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
}
public virtual void testCompleteProcessWithCallActivity()
{
//given process with user task before multi-instance call activity
ProcessInstance processInstance = rule.processInstance();
TaskQuery taskQuery = rule.TaskService.createTaskQuery().processInstanceId(processInstance.Id);
Task taskBeforeSubProcess = taskQuery.taskName("Task before multi-instance").singleResult();
assertNotNull(taskBeforeSubProcess);
//when the task before is complete the process leads to calling the multi-instance subprocess
rule.TaskService.complete(taskBeforeSubProcess.Id);
Task taskAfterSubProcess = taskQuery.taskName("Task after multi-instance").singleResult();
assertNotNull(taskAfterSubProcess);
//after completing the after task the process instance ends
rule.TaskService.complete(taskAfterSubProcess.Id);
rule.assertScenarioEnded();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sendSignalToStartAndIntermediateCatchEventWithAuthenticatedTenant()
public virtual void sendSignalToStartAndIntermediateCatchEventWithAuthenticatedTenant()
{
testRule.deployForTenant(TENANT_ONE, SIGNAL_START_PROCESS, SIGNAL_CATCH_PROCESS);
testRule.deployForTenant(TENANT_TWO, SIGNAL_START_PROCESS, SIGNAL_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("signalCatch").processDefinitionTenantId(TENANT_ONE).execute();
engineRule.RuntimeService.createProcessInstanceByKey("signalCatch").processDefinitionTenantId(TENANT_TWO).execute();
engineRule.IdentityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
engineRule.RuntimeService.createSignalEvent("signal").send();
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageToIntermediateCatchEventDisabledTenantCheck()
public virtual void correlateMessageToIntermediateCatchEventDisabledTenantCheck()
{
testRule.deployForTenant(TENANT_ONE, MESSAGE_CATCH_PROCESS);
testRule.deployForTenant(TENANT_TWO, MESSAGE_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_ONE).execute();
engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_TWO).execute();
engineRule.ProcessEngineConfiguration.TenantCheckEnabled = false;
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.createMessageCorrelation("message").tenantId(TENANT_ONE).correlate();
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(0L));
}
// io mapping ////////////////////////////////////////////////////////////////////////////////////////////////////////
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSetVariableOnInputMapping()
public virtual void testSetVariableOnInputMapping()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance modelInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).userTask(TASK_WITH_CONDITION_ID).camundaInputParameter(VARIABLE_NAME, "1").name(TASK_WITH_CONDITION).endEvent().done();
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).userTask(TASK_WITH_CONDITION_ID).camundaInputParameter(VARIABLE_NAME, "1").name(TASK_WITH_CONDITION).endEvent().done();
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, true);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
Task task = taskQuery.singleResult();
//when task before is completed
taskService.complete(task.Id);
//then conditional boundary event should triggered with the default evaluation behavior
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(TASK_AFTER_CONDITIONAL_BOUNDARY_EVENT, tasksAfterVariableIsSet[0].Name);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void correlateMessageToStartAndIntermediateCatchEventWithNoAuthenticatedTenants()
public virtual void correlateMessageToStartAndIntermediateCatchEventWithNoAuthenticatedTenants()
{
testRule.deploy(MESSAGE_START_PROCESS, MESSAGE_CATCH_PROCESS);
testRule.deployForTenant(TENANT_ONE, MESSAGE_START_PROCESS, MESSAGE_CATCH_PROCESS);
engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").processDefinitionWithoutTenantId().execute();
engineRule.RuntimeService.createProcessInstanceByKey("messageCatch").processDefinitionTenantId(TENANT_ONE).execute();
engineRule.IdentityService.setAuthentication("user", null, null);
engineRule.RuntimeService.createMessageCorrelation("message").correlateAll();
engineRule.IdentityService.clearAuthentication();
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.count(), @is(2L));
assertThat(query.withoutTenantId().count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void suspendAndActivateProcessInstancesIncludingUserTasksForAllTenants()
public virtual void suspendAndActivateProcessInstancesIncludingUserTasksForAllTenants()
{
// given activated user tasks
TaskQuery query = engineRule.TaskService.createTaskQuery();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
// first suspend
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).suspend();
assertThat(query.active().count(), @is(0L));
assertThat(query.suspended().count(), @is(3L));
// then activate
engineRule.RuntimeService.updateProcessInstanceSuspensionState().byProcessDefinitionKey(PROCESS_DEFINITION_KEY).activate();
assertThat(query.active().count(), @is(3L));
assertThat(query.suspended().count(), @is(0L));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableOnInputMappingInSubProcessWithBoundary()
public virtual void testNonInterruptingSetVariableOnInputMappingInSubProcessWithBoundary()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).camundaInputParameter(VARIABLE_NAME, "1").embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, false);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when input mapping sets variable
//then conditional boundary event should triggered and also conditional start event in sub process
//via the default evaluation behavior but not the global event sub process
//since variable is only local
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(3, tasksAfterVariableIsSet.Count);
assertTaskNames(tasksAfterVariableIsSet, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, TASK_AFTER_CONDITIONAL_BOUNDARY_EVENT, TASK_WITH_CONDITION);
}
// io mapping in sub process /////////////////////////////////////////////////////////////////////////////////////////
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSetVariableOnInputMappingInSubProcessWithBoundary()
public virtual void testSetVariableOnInputMappingInSubProcessWithBoundary()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).camundaInputParameter(VARIABLE_NAME, "1").embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
modelInstance = addEventSubProcess(modelInstance, SUB_PROCESS_ID, TASK_AFTER_COND_START_EVENT_IN_SUB_PROCESS, true);
deployMixedProcess(modelInstance, CONDITIONAL_EVENT_PROCESS_KEY, SUB_PROCESS_ID, true);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when input mapping sets variable
//then conditional boundary event should triggered from the default evaluation behavior
// The event sub process inside the sub process should not since the scope is lower than from the boundary.
// The global event sub process should not since the variable is only locally.
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(1, tasksAfterVariableIsSet.Count);
assertEquals(TASK_AFTER_CONDITIONAL_BOUNDARY_EVENT, tasksAfterVariableIsSet[0].Name);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSetVariableOnEndExecutionListenerInSubProcess()
public virtual void testSetVariableOnEndExecutionListenerInSubProcess()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance modelInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).camundaExecutionListenerExpression(org.camunda.bpm.engine.delegate.ExecutionListener_Fields.EVENTNAME_END, EXPR_SET_VARIABLE).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).camundaExecutionListenerExpression([email protected]_Fields.EVENTNAME_END, EXPR_SET_VARIABLE).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
deployMixedProcess(modelInstance, SUB_PROCESS_ID, true);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
Task task = taskQuery.singleResult();
//when task before is completed
taskService.complete(task.Id);
//then conditional boundary should not triggered but conditional start event
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(TASK_AFTER_CONDITIONAL_START_EVENT, tasksAfterVariableIsSet[0].Name);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableOnOutputMappingInSubProcess()
public virtual void testNonInterruptingSetVariableOnOutputMappingInSubProcess()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance modelInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).camundaOutputParameter(VARIABLE_NAME, "1").name(TASK_WITH_CONDITION).userTask().name(TASK_AFTER_OUTPUT_MAPPING).endEvent().subProcessDone().endEvent().done();
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_WITH_CONDITION_ID).camundaOutputParameter(VARIABLE_NAME, "1").name(TASK_WITH_CONDITION).userTask().name(TASK_AFTER_OUTPUT_MAPPING).endEvent().subProcessDone().endEvent().done();
deployMixedProcess(modelInstance, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when task before is completed
taskService.complete(taskQuery.singleResult().Id);
//then conditional boundary should not triggered but conditional start event
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(2, tasksAfterVariableIsSet.Count);
assertTaskNames(tasksAfterVariableIsSet, TASK_AFTER_CONDITIONAL_START_EVENT, TASK_AFTER_OUTPUT_MAPPING);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testNonInterruptingSetVariableOnStartExecutionListenerInSubProcess()
public virtual void testNonInterruptingSetVariableOnStartExecutionListenerInSubProcess()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.model.bpmn.BpmnModelInstance modelInstance = org.camunda.bpm.model.bpmn.Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).userTask(TASK_WITH_CONDITION_ID).camundaExecutionListenerExpression(org.camunda.bpm.engine.delegate.ExecutionListener_Fields.EVENTNAME_START, EXPR_SET_VARIABLE).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(CONDITIONAL_EVENT_PROCESS_KEY).startEvent().subProcess(SUB_PROCESS_ID).embeddedSubProcess().startEvent().userTask(TASK_BEFORE_CONDITION_ID).name(TASK_BEFORE_CONDITION).userTask(TASK_WITH_CONDITION_ID).camundaExecutionListenerExpression([email protected]_Fields.EVENTNAME_START, EXPR_SET_VARIABLE).name(TASK_WITH_CONDITION).endEvent().subProcessDone().endEvent().done();
deployMixedProcess(modelInstance, SUB_PROCESS_ID, false);
// given
ProcessInstance procInst = runtimeService.startProcessInstanceByKey(CONDITIONAL_EVENT_PROCESS_KEY);
TaskQuery taskQuery = taskService.createTaskQuery().processInstanceId(procInst.Id);
//when task before is completed
taskService.complete(taskQuery.singleResult().Id);
//then conditional boundary should triggered via default evaluation behavior
//and conditional start event via delayed events
tasksAfterVariableIsSet = taskQuery.list();
assertEquals(3, tasksAfterVariableIsSet.Count);
assertTaskNames(tasksAfterVariableIsSet, TASK_AFTER_CONDITIONAL_START_EVENT, TASK_AFTER_CONDITIONAL_BOUNDARY_EVENT, TASK_WITH_CONDITION);
}
public void execute(ProcessEngine engine, string scenarioName)
{
// boolean filter
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterBooleanVariable", Variables.createVariables().putValue("booleanVariable", true));
TaskQuery query = engine.TaskService.createTaskQuery().processVariableValueEquals("booleanVariable", true);
Filter filter = engine.FilterService.newTaskFilter("filterBooleanVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
// int filter
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterIntVariable", Variables.createVariables().putValue("intVariable", 7));
query = engine.TaskService.createTaskQuery().processVariableValueEquals("intVariable", 7);
filter = engine.FilterService.newTaskFilter("filterIntVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
// int out of range filter
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterIntOutOfRangeVariable", Variables.createVariables().putValue("longVariable", int.MaxValue + 1L));
query = engine.TaskService.createTaskQuery().processVariableValueEquals("longVariable", int.MaxValue + 1L);
filter = engine.FilterService.newTaskFilter("filterIntOutOfRangeVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
// double filter
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterDoubleVariable", Variables.createVariables().putValue("doubleVariable", 88.89D));
query = engine.TaskService.createTaskQuery().processVariableValueEquals("doubleVariable", 88.89D);
filter = engine.FilterService.newTaskFilter("filterDoubleVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
// string filter
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterStringVariable", Variables.createVariables().putValue("stringVariable", "aVariableValue"));
query = engine.TaskService.createTaskQuery().processVariableValueEquals("stringVariable", "aVariableValue");
filter = engine.FilterService.newTaskFilter("filterStringVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
// filter null
engine.RuntimeService.startProcessInstanceByKey("oneTaskProcess_710", "TaskFilterVariablesScenario_filterNullVariable", Variables.createVariables().putValue("nullVariable", null));
query = engine.TaskService.createTaskQuery().processVariableValueEquals("nullVariable", null);
filter = engine.FilterService.newTaskFilter("filterNullVariable");
filter.Query = query;
engine.FilterService.saveFilter(filter);
}
