//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testResourceName()
public virtual void testResourceName()
{
ProcessEngine processEngine = ProgrammaticBeanLookup.lookup(typeof(ProcessEngine));
Assert.assertNotNull(processEngine);
RepositoryService repositoryService = processEngine.RepositoryService;
ProcessDefinitionQuery query = repositoryService.createProcessDefinitionQuery();
ProcessDefinition definition = query.processDefinitionKey("process-0").singleResult();
Assert.assertEquals("process0.bpmn", definition.ResourceName);
definition = query.processDefinitionKey("process-1").singleResult();
Assert.assertEquals("processes/process1.bpmn", definition.ResourceName);
definition = query.processDefinitionKey("process-2").singleResult();
Assert.assertEquals("process2.bpmn", definition.ResourceName);
definition = query.processDefinitionKey("process-3").singleResult();
Assert.assertEquals("subDirectory/process3.bpmn", definition.ResourceName);
definition = query.processDefinitionKey("process-4").singleResult();
Assert.assertEquals("process4.bpmn", definition.ResourceName);
definition = query.processDefinitionKey("process-5").singleResult();
Assert.assertEquals("subDirectory/process5.bpmn", definition.ResourceName);
}
public void execute(ProcessEngine engine, string scenarioName)
{
// throw compensation; the compensation handler for userTask should then be active
Task beforeCompensateTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).singleResult();
engine.TaskService.complete(beforeCompensateTask.Id);
}
public void execute(ProcessEngine engine, string scenarioName)
{
ProcessInstance procInstance = engine.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, scenarioName);
Job job = engine.ManagementService.createJobQuery().processInstanceId(procInstance.Id).singleResult();
engine.ManagementService.executeJob(job.Id);
}
public static void Main(string[] args)
{
ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl)ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("camunda.cfg.xml");
ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
// register test scenarios
ScenarioRunner runner = new ScenarioRunner(processEngine, ENGINE_VERSION);
// cmmn sentries
runner.setupScenarios(typeof(SentryScenario));
// compensation
runner.setupScenarios(typeof(SingleActivityCompensationScenario));
runner.setupScenarios(typeof(NestedCompensationScenario));
runner.setupScenarios(typeof(SingleActivityConcurrentCompensationScenario));
runner.setupScenarios(typeof(ParallelMultiInstanceCompensationScenario));
runner.setupScenarios(typeof(SequentialMultiInstanceCompensationScenario));
runner.setupScenarios(typeof(NestedMultiInstanceCompensationScenario));
runner.setupScenarios(typeof(InterruptingEventSubProcessCompensationScenario));
runner.setupScenarios(typeof(NonInterruptingEventSubProcessCompensationScenario));
runner.setupScenarios(typeof(InterruptingEventSubProcessNestedCompensationScenario));
// job
runner.setupScenarios(typeof(JobMigrationScenario));
// boundary events
runner.setupScenarios(typeof(NonInterruptingBoundaryEventScenario));
processEngine.close();
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RuntimeService.startProcessInstanceByKey("NestedInterruptingErrorEventSubprocessScenario", scenarioName);
// trigger the inner, non-interrupting event subprocess
engine.RuntimeService.createMessageCorrelation("Message").processInstanceBusinessKey(scenarioName).correlate();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @OperateOnDeployment("test1") public void testNonExistingEngineRetrieval()
public virtual void testNonExistingEngineRetrieval()
{
ProcessEngineService engineService = BpmPlatform.ProcessEngineService;
ProcessEngine engine = engineService.getProcessEngine("aNonExistingEngineName");
Assert.assertNull(engine);
}
public void execute(ProcessEngine engine, string scenarioName)
{
ProcessInstance procInst = engine.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, scenarioName);
Task task = engine.TaskService.createTaskQuery().processInstanceId(procInst.Id).singleResult();
engine.TaskService.complete(task.Id);
}
public void execute(ProcessEngine engine, string scenarioName)
{
deploy(engine, scenarioName);
engine.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, scenarioName);
engine.ExternalTaskService.fetchAndLock(1, scenarioName).topic(scenarioName, LOCK_TIME).execute();
}
public ProcessEngineAwareStep(ProcessEngine processEngine)
{
this.processEngine = processEngine;
runtimeService = processEngine.RuntimeService;
taskService = processEngine.TaskService;
repositoryService = processEngine.RepositoryService;
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RepositoryService.createDeployment().addModelInstance("process.bpmn", Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done()).deploy();
engine.RepositoryService.createDeployment().addModelInstance("rootProcess.bpmn", Bpmn.createExecutableProcess("rootProcess").startEvent().callActivity().calledElement("process").endEvent().done()).deploy();
engine.RuntimeService.startProcessInstanceByKey("rootProcess", "rootProcessInstance");
}
// queries /////////////////////////////////
protected internal virtual CaseSentryPartQueryImpl createCaseSentryPartQuery()
{
ProcessEngine processEngine = rule.ProcessEngine;
ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl)processEngine.ProcessEngineConfiguration;
CommandExecutor commandExecutor = processEngineConfiguration.CommandExecutorTxRequiresNew;
return(new CaseSentryPartQueryImpl(commandExecutor));
}
public void execute(ProcessEngine processEngine, string s)
{
ClockUtil.CurrentTime = TIMESTAMP;
deployModel(processEngine, DEPLOYMENT_NAME, PROCESS_DEFINITION_KEY, DEPLOYMENT_MODEL);
ClockUtil.reset();
}
public void execute(ProcessEngine processEngine, string s)
{
TaskEntity task = TaskEntity.create();
task.Name = TASK_NAME;
task.CreateTime = TIMESTAMP;
processEngine.TaskService.saveTask(task);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void setup()
{
engine = processEngineRule.ProcessEngine;
taskService = engine.TaskService;
historyService = engine.HistoryService;
runtimeService = engine.RuntimeService;
repositoryService = engine.RepositoryService;
}
public void execute(ProcessEngine engine, string scenarioName)
{
ProcessInstance instance = engine.RuntimeService.startProcessInstanceByKey("NonInterruptingTimerBoundaryEventScenario", scenarioName);
Job job = engine.ManagementService.createJobQuery().processInstanceId(instance.Id).singleResult();
engine.ManagementService.executeJob(job.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void setup()
{
engine = PerfTestProcessEngine.Instance;
taskService = engine.TaskService;
historyService = engine.HistoryService;
runtimeService = engine.RuntimeService;
repositoryService = engine.RepositoryService;
}
public TestFixture(ProcessEngine processEngine)
{
this.processEngine = processEngine;
repositoryService = processEngine.RepositoryService;
runtimeService = processEngine.RuntimeService;
managementService = processEngine.ManagementService;
taskService = processEngine.TaskService;
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RuntimeService.startProcessInstanceByKey("SubprocessParallelThrowCompensationScenario", scenarioName);
// create the compensation event subscription and wait before throwing compensation
Task userTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).singleResult();
engine.TaskService.complete(userTask.Id);
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RuntimeService.startProcessInstanceByKey("SubprocessParallelCreateCompensationScenario", scenarioName);
// create the compensation event subscription for the first user task
// execution continues from userTask1 to afterUserTask1
Task userTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).taskDefinitionKey("userTask1").singleResult();
engine.TaskService.complete(userTask.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeployProcessArchive()
public virtual void testDeployProcessArchive()
{
ProcessEngine processEngine = ProgrammaticBeanLookup.lookup(typeof(ProcessEngine));
Assert.assertNotNull(processEngine);
RepositoryService repositoryService = processEngine.RepositoryService;
long count = repositoryService.createProcessDefinitionQuery().processDefinitionKey("testDeployProcessArchive").count();
Assert.assertEquals(1, count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPAGroovyProcessEnginePlugin()
public virtual void testPAGroovyProcessEnginePlugin()
{
ProcessEngine groovyEngine = processEngineService.getProcessEngine("groovy");
Assert.assertNotNull(groovyEngine);
ProcessInstance pi = groovyEngine.RuntimeService.startProcessInstanceByKey("groovy");
HistoricProcessInstance hpi = groovyEngine.HistoryService.createHistoricProcessInstanceQuery().processDefinitionKey("groovy").finished().singleResult();
assertEquals(pi.Id, hpi.Id);
}
public void execute(ProcessEngine engine, string scenarioName)
{
// given
IdentityService identityService = engine.IdentityService;
User user = identityService.newUser(USER_NAME);
user.Password = USER_PWD;
// when
identityService.saveUser(user);
}
public void execute(ProcessEngine processEngine, string scenarioName)
{
ClockUtil.CurrentTime = TIMESTAMP;
deployModel(processEngine, PROCESS_DEFINITION_KEY, PROCESS_DEFINITION_KEY, EXT_TASK_MODEL);
processEngine.RuntimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY, scenarioName);
processEngine.ExternalTaskService.fetchAndLock(1, WORKER_ID).topic(TOPIC_NAME, LOCK_TIME).execute();
ClockUtil.reset();
}
public void execute(ProcessEngine engine, string scenarioName)
{
string processDefinitionId = engine.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("oneTaskProcessInstanceModification_710").singleResult().Id;
string processInstanceId = engine.RuntimeService.startProcessInstanceById(processDefinitionId, "ProcessInstanceModificationScenario").Id;
engine.RuntimeService.createModification(processDefinitionId).processInstanceIds(processInstanceId).startBeforeActivity("userTask2").execute();
ActivityInstance tree = engine.RuntimeService.getActivityInstance(processInstanceId);
engine.RuntimeService.createProcessInstanceModification(processInstanceId).cancelActivityInstance(tree.getActivityInstances("userTask1")[0].Id).cancelTransitionInstance(tree.getTransitionInstances("userTask2")[0].Id).executeAsync();
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RuntimeService.startProcessInstanceByKey("InterruptingEventSubProcessCompensationScenario", scenarioName);
// trigger the event subprocess
engine.RuntimeService.correlateMessage("EventSubProcessMessage");
// complete the task to compensate and then throw compensation
Task eventSubProcessTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).singleResult();
engine.TaskService.complete(eventSubProcessTask.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPaAsEjbModule()
public virtual void testPaAsEjbModule()
{
ProcessEngine processEngine = ProgrammaticBeanLookup.lookup(typeof(ProcessEngine));
Assert.assertNotNull(processEngine);
runtimeService.startProcessInstanceByKey("paAsEjbJar-process");
Assert.assertEquals(1, runtimeService.createProcessInstanceQuery().count());
waitForJobExecutorToProcessAllJobs();
Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
public static void Main(string[] args)
{
ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl)ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("camunda.cfg.xml");
ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
// register test scenarios
ScenarioRunner runner = new ScenarioRunner(processEngine, ENGINE_VERSION);
// event subprocesses
runner.setupScenarios(typeof(InterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(NonInterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(NestedNonInterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(ParallelNestedNonInterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(NestedParallelNonInterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(NestedNonInterruptingEventSubprocessNestedSubprocessScenario));
runner.setupScenarios(typeof(NestedInterruptingErrorEventSubprocessScenario));
runner.setupScenarios(typeof(TwoLevelNestedNonInterruptingEventSubprocessScenario));
runner.setupScenarios(typeof(NestedInterruptingEventSubprocessParallelScenario));
// multi instance
runner.setupScenarios(typeof(SequentialMultiInstanceSubprocessScenario));
runner.setupScenarios(typeof(NestedSequentialMultiInstanceSubprocessScenario));
runner.setupScenarios(typeof(MultiInstanceReceiveTaskScenario));
runner.setupScenarios(typeof(ParallelMultiInstanceSubprocessScenario));
// async
runner.setupScenarios(typeof(AsyncParallelMultiInstanceScenario));
runner.setupScenarios(typeof(AsyncSequentialMultiInstanceScenario));
// boundary event
runner.setupScenarios(typeof(NonInterruptingBoundaryEventScenario));
runner.setupScenarios(typeof(NestedNonInterruptingBoundaryEventOnInnerSubprocessScenario));
runner.setupScenarios(typeof(NestedNonInterruptingBoundaryEventOnOuterSubprocessScenario));
// compensation
runner.setupScenarios(typeof(SingleActivityCompensationScenario));
runner.setupScenarios(typeof(SubprocessCompensationScenario));
runner.setupScenarios(typeof(TransactionCancelCompensationScenario));
runner.setupScenarios(typeof(InterruptingEventSubprocessCompensationScenario));
runner.setupScenarios(typeof(SubprocessParallelThrowCompensationScenario));
runner.setupScenarios(typeof(SubprocessParallelCreateCompensationScenario));
// plain tasks
runner.setupScenarios(typeof(OneTaskScenario));
runner.setupScenarios(typeof(OneScopeTaskScenario));
runner.setupScenarios(typeof(ParallelTasksScenario));
runner.setupScenarios(typeof(ParallelScopeTasksScenario));
// event-based gateway
runner.setupScenarios(typeof(EventBasedGatewayScenario));
processEngine.close();
}
public void execute(ProcessEngine engine, string scenarioName)
{
engine.RuntimeService.startProcessInstanceByKey("SequentialMultiInstanceCompensationSingleActivityHandlerScenario", scenarioName);
// complete two out of three MI tasks
Task miTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).singleResult();
engine.TaskService.complete(miTask.Id);
miTask = engine.TaskService.createTaskQuery().processInstanceBusinessKey(scenarioName).singleResult();
engine.TaskService.complete(miTask.Id);
}
public static void Main(string[] args)
{
ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl)ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("camunda.cfg.xml");
ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
// register test scenarios
ScenarioRunner runner = new ScenarioRunner(processEngine, ENGINE_VERSION);
// compensation
runner.setupScenarios(typeof(DeployProcessWithoutIsExecutableAttributeScenario));
processEngine.close();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotActiateJobExecutor()
public virtual void shouldNotActiateJobExecutor()
{
ProcessEngine processEngine = processEngineService.getProcessEngine("jobExecutorActivate-FALSE-engine");
ProcessEngineConfiguration configuration = processEngine.ProcessEngineConfiguration;
JobExecutor jobExecutor = ((ProcessEngineConfigurationImpl)configuration).JobExecutor;
assertFalse(jobExecutor.Active);
processEngine = processEngineService.getProcessEngine("jobExecutorActivate-UNDEFINED-engine");
configuration = processEngine.ProcessEngineConfiguration;
jobExecutor = ((ProcessEngineConfigurationImpl)configuration).JobExecutor;
assertTrue(jobExecutor.Active);
}
