public virtual void testConcurrentFetchAndDelete()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String processInstanceId = deployAndStartProcess(PROCESS_WITH_USERTASK, org.camunda.bpm.engine.variable.Variables.createVariables().putValue(VARIABLE_NAME, org.camunda.bpm.engine.variable.Variables.byteArrayValue(VARIABLE_VALUE.getBytes()))).getId();
string processInstanceId = deployAndStartProcess(PROCESS_WITH_USERTASK, Variables.createVariables().putValue(VARIABLE_NAME, Variables.byteArrayValue(VARIABLE_VALUE.GetBytes()))).Id;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String[] historicByteArrayId = new String[1];
string[] historicByteArrayId = new string[1];
commandExecutor.execute(new CommandAnonymousInnerClass(this, processInstanceId, historicByteArrayId));
ThreadControl asyncThread = executeControllableCommand(new AsyncThread(this, processInstanceId, historicByteArrayId[0]));
asyncThread.waitForSync();
commandExecutor.execute(new CommandAnonymousInnerClass2(this, historicByteArrayId));
commandExecutor.execute(new CommandAnonymousInnerClass3(this, historicByteArrayId));
// when
asyncThread.makeContinue();
asyncThread.waitUntilDone();
// then
assertThat(runtimeService.createVariableInstanceQuery().singleResult().Name, @is(VARIABLE_NAME));
assertThat(StringHelper.NewString((sbyte[])runtimeService.createVariableInstanceQuery().singleResult().Value), @is(ANOTHER_VARIABLE_VALUE));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSerializeFileVariable()
public virtual void testSerializeFileVariable()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
org.camunda.bpm.engine.repository.Deployment deployment = repositoryService.createDeployment().addModelInstance("process.bpmn", modelInstance).deploy();
VariableMap variables = Variables.createVariables();
string filename = "test.txt";
string type = "text/plain";
FileValue fileValue = Variables.fileValue(filename).file("ABC".GetBytes()).encoding("UTF-8").mimeType(type).create();
variables.put("file", fileValue);
runtimeService.startProcessInstanceByKey("process", variables);
Task task = taskService.createTaskQuery().singleResult();
VariableInstance result = runtimeService.createVariableInstanceQuery().processInstanceIdIn(task.ProcessInstanceId).singleResult();
FileValue value = (FileValue)result.TypedValue;
assertThat(value.Filename, @is(filename));
assertThat(value.MimeType, @is(type));
assertThat(value.Encoding, @is("UTF-8"));
assertThat(value.EncodingAsCharset, @is(Charset.forName("UTF-8")));
using (Scanner scanner = new Scanner(value.Value))
{
assertThat(scanner.nextLine(), @is("ABC"));
}
// clean up
repositoryService.deleteDeployment(deployment.Id, true);
}
public virtual void testPojo()
{
VariableMap variables = Variables.createVariables().putValue("pojo", new TestPojo("okay", 13.37));
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFallbackSerializerDoesNotOverrideRegularSerializer()
public virtual void testFallbackSerializerDoesNotOverrideRegularSerializer()
{
// given
// that the process engine is configured with a serializer for a certain format
// and a fallback serializer factory for the same format
ProcessEngineConfigurationImpl engineConfiguration = (new StandaloneInMemProcessEngineConfiguration()).setJdbcUrl("jdbc:h2:mem:camunda-forceclose").setProcessEngineName("engine-forceclose");
engineConfiguration.CustomPreVariableSerializers = Arrays.asList <TypedValueSerializer>(new ExampleConstantSerializer());
engineConfiguration.FallbackSerializerFactory = new ExampleSerializerFactory();
processEngine = engineConfiguration.buildProcessEngine();
deployOneTaskProcess(processEngine);
// when setting a variable that no regular serializer can handle
ObjectValue objectValue = Variables.objectValue("foo").serializationDataFormat(ExampleSerializer.FORMAT).create();
ProcessInstance pi = processEngine.RuntimeService.startProcessInstanceByKey("oneTaskProcess", Variables.createVariables().putValueTyped("var", objectValue));
ObjectValue fetchedValue = processEngine.RuntimeService.getVariableTyped(pi.Id, "var", true);
// then the fallback serializer is used
Assert.assertNotNull(fetchedValue);
Assert.assertEquals(ExampleSerializer.FORMAT, fetchedValue.SerializationDataFormat);
Assert.assertEquals(ExampleConstantSerializer.DESERIALIZED_VALUE, fetchedValue.Value);
}
public virtual void testRepeatTaskWithoutEntryCriteriaWhenTerminating()
{
// given
string caseInstanceId = createCaseInstanceByKey(CASE_ID, Variables.createVariables().putValue("repeating", true)).Id;
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
CaseExecution activeCaseExecution = query.active().singleResult();
assertNotNull(activeCaseExecution);
// when (1)
terminate(activeCaseExecution.Id);
// then (1)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
activeCaseExecution = query.active().singleResult();
assertNotNull(activeCaseExecution);
// when (2)
caseService.setVariable(caseInstanceId, "repeating", false);
terminate(activeCaseExecution.Id);
// then (2)
query = caseService.createCaseExecutionQuery();
assertEquals(1, query.count());
assertEquals(caseInstanceId, query.singleResult().Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testAutoCompleteStageWithoutEntryCriteria()
public virtual void testAutoCompleteStageWithoutEntryCriteria()
{
// given
VariableMap variables = Variables.createVariables().putValue("manualActivation", false);
string caseInstanceId = createCaseInstanceByKey("case", variables).Id;
// then (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
string activeTaskId = query.singleResult().Id;
// when (2)
// completing active task
complete(activeTaskId);
// then (2)
// the stage should be completed
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
assertNull(stage);
CaseInstance caseInstance = (CaseInstance)queryCaseExecutionById(caseInstanceId);
assertTrue(caseInstance.Completed);
}
public virtual void testSingleEntryMapping()
{
ProcessInstance processInstance = startTestProcess("single entry");
assertEquals("foo", runtimeService.getVariable(processInstance.Id, "result"));
assertEquals(Variables.stringValue("foo"), runtimeService.getVariableTyped(processInstance.Id, "result"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testStatisticForRootDecisionWithNullInstanceConstraintEvaluation() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testStatisticForRootDecisionWithNullInstanceConstraintEvaluation()
{
//when
decisionService.evaluateDecisionTableByKey(DISH_DECISION).variables(Variables.createVariables().putValue(TEMPERATURE, 21).putValue(DAY_TYPE, WEEKEND)).evaluate();
DecisionRequirementsDefinition decisionRequirementsDefinition = repositoryService.createDecisionRequirementsDefinitionQuery().singleResult();
//when
HistoricDecisionInstanceStatisticsQuery query = historyService.createHistoricDecisionInstanceStatisticsQuery(decisionRequirementsDefinition.Id).decisionInstanceId(null);
//then
try
{
query.count();
}
catch (NullValueException)
{
//expected
}
try
{
query.list();
}
catch (NullValueException)
{
//expected
}
}
public virtual void testSerializationOfUnknownFormat()
{
// given
ProcessInstance instance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
// when
ObjectValue objectValue = Variables.serializedObjectValue("foo").serializationDataFormat("application/foo").objectTypeName("org.camunda.Foo").create();
runtimeService.setVariable(instance.Id, "var", objectValue);
// then
try
{
runtimeService.getVariable(instance.Id, "var");
fail();
}
catch (ProcessEngineException e)
{
assertTextPresent("Fallback serializer cannot handle deserialized objects", e.Message);
}
ObjectValue returnedValue = runtimeService.getVariableTyped(instance.Id, "var", false);
assertFalse(returnedValue.Deserialized);
assertEquals("application/foo", returnedValue.SerializationDataFormat);
assertEquals("foo", returnedValue.ValueSerialized);
assertEquals("org.camunda.Foo", returnedValue.ObjectTypeName);
}
public virtual void decisionRefWithCompositeExpression()
{
VariableMap variables = Variables.createVariables().putValue("version", 1);
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcessCompositeExpression", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
public virtual void testCatchErrorThrownBySignalOfDelegateExpression()
{
VariableMap variables = Variables.createVariables().putValue("myDelegate", new ThrowErrorDelegate());
string pi = runtimeService.startProcessInstanceByKey("testProcess", variables).Id;
assertTrue((bool?)runtimeService.getVariable(pi, "executed"));
assertNull(runtimeService.getVariable(pi, "signaled"));
Execution serviceTask = runtimeService.createExecutionQuery().processInstanceId(pi).activityId("serviceTask").singleResult();
assertNotNull(serviceTask);
runtimeService.setVariables(pi, throwError());
runtimeService.signal(serviceTask.Id);
assertTrue((bool?)runtimeService.getVariable(pi, "executed"));
assertTrue((bool?)runtimeService.getVariable(pi, "signaled"));
Task userTask = taskService.createTaskQuery().processInstanceId(pi).singleResult();
assertNotNull(userTask);
assertEquals("userTaskError", userTask.TaskDefinitionKey);
taskService.complete(userTask.Id);
}
public override FileValue readValue(ValueFields valueFields, bool deserializeValue)
{
string fileName = valueFields.TextValue;
if (string.ReferenceEquals(fileName, null))
{
// ensure file name is not null
fileName = "";
}
FileValueBuilder builder = Variables.fileValue(fileName);
if (valueFields.ByteArrayValue != null)
{
builder.file(valueFields.ByteArrayValue);
}
// to ensure the same array size all the time
if (!string.ReferenceEquals(valueFields.TextValue2, null))
{
string[] split = Arrays.copyOf(valueFields.TextValue2.Split(MIMETYPE_ENCODING_SEPARATOR, NR_OF_VALUES_IN_TEXTFIELD2), NR_OF_VALUES_IN_TEXTFIELD2);
string mimeType = returnNullIfEmptyString(split[0]);
string encoding = returnNullIfEmptyString(split[1]);
builder.mimeType(mimeType);
builder.encoding(encoding);
}
return(builder.create());
}
public virtual void testPojo()
{
// given
VariableMap variables = Variables.createVariables().putValue("pojo", new TestPojo("okay", 13.37));
CaseInstance caseInstance = createCaseInstanceByKey(CASE_KEY, variables);
assertEquals("okay", getDecisionResult(caseInstance));
}
protected internal virtual CaseInstance startTestCase(string input)
{
CaseInstance caseInstance = createCaseInstanceByKey("case", Variables.createVariables().putValue("input", input));
results = DecisionResultTestListener.DecisionResult;
assertNotNull(results);
return(caseInstance);
}
public virtual void testSingleEntry()
{
startTestProcess("single entry");
DmnDecisionResultEntries firstOutput = results.get(0);
assertEquals("foo", firstOutput.FirstEntry);
assertEquals(Variables.stringValue("foo"), firstOutput.FirstEntryTyped);
}
public override ObjectValue readValue(ValueFields valueFields, bool deserializeObjectValue)
{
if (!string.ReferenceEquals(valueFields.TextValue, null) && !string.ReferenceEquals(valueFields.TextValue2, null))
{
object jpaEntity = mappings.getJPAEntity(valueFields.TextValue, valueFields.TextValue2);
return(Variables.objectValue(jpaEntity).create());
}
return(Variables.objectValue(null).create());
}
public virtual void testManualActivationRuleWithoutCondition()
{
createCaseInstanceByKey("case", Variables.createVariables().putValue("manual", false));
CaseExecution taskExecution = queryCaseExecutionByActivityId("PI_HumanTask_1");
assertNotNull(taskExecution);
assertTrue(taskExecution.Enabled);
}
public virtual void testCallDecisionWithRequiredDecisions()
{
// given
CaseInstance caseInstance = createCaseInstanceByKey(CASE_KEY, Variables.createVariables().putValue("testDecision", "dish-decision").putValue("temperature", 32).putValue("dayType", "Weekend"));
// then
assertNull(queryCaseExecutionByActivityId(DECISION_TASK));
assertEquals("Light salad", getDecisionResult(caseInstance));
}
public virtual void testExecutionWithScriptTargetScope()
{
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("Process_MultiInstanceCallAcitivity", variables);
// it runs without any problems
assertThat(processInstance.Ended, @is(true));
assertThat(((ProcessInstanceWithVariablesImpl)processInstance).Variables.containsKey("targetOrderId"), @is(false));
}
public virtual void testCallDecisionAsExpressionStartsWithHash()
{
// given
CaseInstance caseInstance = createCaseInstanceByKey(CASE_KEY, Variables.createVariables().putValue("testDecision", "testDecision"));
// then
assertNull(queryCaseExecutionByActivityId(DECISION_TASK));
assertEquals("okay", getDecisionResult(caseInstance));
}
public virtual void testCollectSumHitPolicySingleEntryList()
{
startTestProcess("single entry list");
assertEquals(1, results.size());
DmnDecisionResultEntries firstOutput = results.get(0);
assertEquals(33, firstOutput.FirstEntry);
assertEquals(Variables.integerValue(33), firstOutput.FirstEntryTyped);
}
public virtual void testCustomOutputMapping()
{
ProcessInstance processInstance = startTestProcess("multiple entries");
assertEquals("foo", runtimeService.getVariable(processInstance.Id, "result1"));
assertEquals(Variables.stringValue("foo"), runtimeService.getVariableTyped(processInstance.Id, "result1"));
assertEquals("bar", runtimeService.getVariable(processInstance.Id, "result2"));
assertEquals(Variables.stringValue("bar"), runtimeService.getVariableTyped(processInstance.Id, "result2"));
}
public virtual void testCollectCountHitPolicyNoOutput()
{
startTestProcess("no output");
assertEquals(1, results.size());
DmnDecisionResultEntries firstOutput = results.get(0);
assertEquals(0, firstOutput.FirstEntry);
assertEquals(Variables.integerValue(0), firstOutput.FirstEntryTyped);
}
public virtual void execute(DelegateExecution execution)
{
execution.setVariable("jsonVariable", Variables.untypedValue(jsonValue("{}"), true));
// when
TypedValue typedValue = execution.getVariableTyped("jsonVariable");
// then
assertThat(typedValue.Transient, @is(true));
}
public override object resolveValue(ObjectMapper objectMapper)
{
object value = base.resolveValue(objectMapper);
if (value != null && value.GetType().IsAssignableFrom(typeof(Number)))
{
return(Variables.numberValue((Number)value));
}
return(value);
}
public virtual void testProcessVariableMapLocal()
{
BusinessProcess businessProcess = getBeanInstance(typeof(BusinessProcess));
businessProcess.startProcessByKey("businessProcessBeanTest");
VariableMap variables = (VariableMap)getBeanInstance("processVariableMapLocal");
assertNotNull(variables);
///////////////////////////////////////////////////////////////////
// Put a variable via BusinessProcess and get it via VariableMap //
///////////////////////////////////////////////////////////////////
string aValue = "aValue";
businessProcess.setVariableLocal(VARNAME_1, Variables.stringValue(aValue));
// Legacy API
assertEquals(aValue, variables.get(VARNAME_1));
// Typed variable API
TypedValue aTypedValue = variables.getValueTyped(VARNAME_1);
assertEquals(ValueType.STRING, aTypedValue.Type);
assertEquals(aValue, aTypedValue.Value);
assertEquals(aValue, variables.getValue(VARNAME_1, typeof(string)));
// Type API with wrong type
try
{
variables.getValue(VARNAME_1, typeof(Integer));
fail("ClassCastException expected!");
}
catch (System.InvalidCastException ex)
{
assertEquals("Cannot cast variable named 'aVariable' with value 'aValue' to type 'class java.lang.Integer'.", ex.Message);
}
///////////////////////////////////////////////////////////////////
// Put a variable via VariableMap and get it via BusinessProcess //
///////////////////////////////////////////////////////////////////
string anotherValue = "anotherValue";
variables.put(VARNAME_2, Variables.stringValue(anotherValue));
// Legacy API
assertEquals(anotherValue, businessProcess.getVariableLocal(VARNAME_2));
// Typed variable API
TypedValue anotherTypedValue = businessProcess.getVariableLocalTyped(VARNAME_2);
assertEquals(ValueType.STRING, anotherTypedValue.Type);
assertEquals(anotherValue, anotherTypedValue.Value);
}
//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()
{
decisionService = engineRule.DecisionService;
repositoryService = engineRule.RepositoryService;
historyService = engineRule.HistoryService;
identityService = engineRule.IdentityService;
testRule.deploy(DISH_DRG_DMN);
decisionService.evaluateDecisionByKey(DISH_DECISION).variables(Variables.createVariables().putValue(TEMPERATURE, 21).putValue(DAY_TYPE, WEEKEND)).evaluate();
}
public virtual void testWithDelegateVariableMapping()
{
BpmnModelInstance instance = Bpmn.createExecutableProcess("process1").startEvent().subProcess("SubProcess_1").embeddedSubProcess().startEvent().callActivity().calledElement("Process_StuffDoer").camundaVariableMappingClass("org.camunda.bpm.engine.test.api.variables.scope.SetVariableMappingDelegate").serviceTask().camundaClass("org.camunda.bpm.engine.test.api.variables.scope.AssertVariableScopeDelegate").endEvent().subProcessDone().endEvent().done();
instance = modify(instance).activityBuilder("SubProcess_1").multiInstance().parallel().camundaCollection("orderIds").camundaElementVariable("orderId").done();
ProcessDefinition processDefinition = testHelper.deployAndGetDefinition(instance);
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
engineRule.RuntimeService.startProcessInstanceById(processDefinition.Id, variables);
}
public virtual void testExecutionWithoutProperTargetScope()
{
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
//fails due to inappropriate variable scope target
thrown.expect(typeof(ScriptEvaluationException));
ProcessDefinition processDefinition = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("Process_MultiInstanceCallAcitivity").singleResult();
thrown.expectMessage(startsWith("Unable to evaluate script while executing activity 'CallActivity_1' in the process definition with id '" + processDefinition.Id + "': org.camunda.bpm.engine.ProcessEngineException: ENGINE-20011 Scope with specified activity Id NOT_EXISTING and execution"));
engineRule.RuntimeService.startProcessInstanceByKey("Process_MultiInstanceCallAcitivity", variables);
}
public virtual void testSingleEntryList()
{
startTestProcess("single entry list");
assertEquals(2, results.size());
foreach (DmnDecisionResultEntries output in results)
{
assertEquals("foo", output.FirstEntry);
assertEquals(Variables.stringValue("foo"), output.FirstEntryTyped);
}
}
