Java Code Examples for org.camunda.bpm.engine.runtime.ProcessInstanceQuery#singleResult()

public ProcessInstance retrieveProcessInstance(String processInstanceId) {
	if (StringUtils.isBlank(processInstanceId)) {
		throw new IllegalArgumentException("Process instance ID is blank.");
	}

	ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId);

	ProcessInstance procInst = query.singleResult();

	if (procInst == null) {
		throw new WecubeCoreException(
				String.format("Such process instance with id [%s] does not exist.", processInstanceId));
	}

	return procInst;
}
 

@Test
@Deployment(resources = {
    "org/camunda/bpm/engine/test/api/runtime/superProcessWithCaseCallActivityInsideSubProcess.bpmn20.xml",
    "org/camunda/bpm/engine/test/api/cmmn/oneTaskCase.cmmn" })
public void testQueryBySubCaseInstanceIdNested() {
  String superProcessInstanceId = runtimeService.startProcessInstanceByKey("subProcessQueryTest").getId();

  String subCaseInstanceId = caseService
      .createCaseInstanceQuery()
      .superProcessInstanceId(superProcessInstanceId)
      .singleResult()
      .getId();

  ProcessInstanceQuery query = runtimeService
      .createProcessInstanceQuery()
      .subCaseInstanceId(subCaseInstanceId);

  assertEquals(1, query.list().size());
  assertEquals(1, query.count());

  ProcessInstance superProcessInstance = query.singleResult();
  assertNotNull(superProcessInstance);
  assertEquals(superProcessInstanceId, superProcessInstance.getId());
}
 

@Test
@Deployment(resources = {
    "org/camunda/bpm/engine/test/api/runtime/superProcessWithCaseCallActivity.bpmn20.xml",
    "org/camunda/bpm/engine/test/api/cmmn/oneTaskCase.cmmn" })
public void testQueryBySubCaseInstanceId() {
  String superProcessInstanceId = runtimeService.startProcessInstanceByKey("subProcessQueryTest").getId();

  String subCaseInstanceId = caseService
      .createCaseInstanceQuery()
      .superProcessInstanceId(superProcessInstanceId)
      .singleResult()
      .getId();

  ProcessInstanceQuery query = runtimeService
      .createProcessInstanceQuery()
      .subCaseInstanceId(subCaseInstanceId);

  assertEquals(1, query.list().size());
  assertEquals(1, query.count());

  ProcessInstance superProcessInstance = query.singleResult();
  assertNotNull(superProcessInstance);
  assertEquals(superProcessInstanceId, superProcessInstance.getId());
}
 

public void testQueryWithReadPermissionOnProcessInstance() {
  // given
  startProcessInstanceByKey(PROCESS_KEY);
  startProcessInstanceByKey(PROCESS_KEY);
  String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();

  startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY);
  startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY);
  startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY);
  startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY);

  createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);

  // when
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessInstance instance = query.singleResult();
  assertNotNull(instance);
  assertEquals(processInstanceId, instance.getId());
}
 

public void testSimpleQueryWithReadPermissionOnProcessInstance() {
  // given
  String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
  createGrantAuthorization(PROCESS_INSTANCE, processInstanceId, userId, READ);

  // when
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessInstance instance = query.singleResult();
  assertNotNull(instance);
  assertEquals(processInstanceId, instance.getId());
}
 

@Test
@Deployment(resources = {"org/camunda/bpm/engine/test/api/cmmn/oneProcessTaskCase.cmmn"})
public void testQueryBySuperCaseInstanceId() {
  String superCaseInstanceId = caseService.createCaseInstanceByKey("oneProcessTaskCase").getId();

  ProcessInstanceQuery query = runtimeService
      .createProcessInstanceQuery()
      .superCaseInstanceId(superCaseInstanceId);

  assertEquals(1, query.list().size());
  assertEquals(1, query.count());

  ProcessInstance subProcessInstance = query.singleResult();
  assertNotNull(subProcessInstance);
}
 

@Test
@Deployment(resources = {"org/camunda/bpm/engine/test/api/runtime/superProcess.bpmn20.xml",
                         "org/camunda/bpm/engine/test/api/runtime/subProcess.bpmn20.xml"})
public void testQueryBySuperProcessInstanceId() {
  ProcessInstance superProcessInstance = runtimeService.startProcessInstanceByKey("subProcessQueryTest");

  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().superProcessInstanceId(superProcessInstance.getId());
  ProcessInstance subProcessInstance = query.singleResult();
  assertNotNull(subProcessInstance);
  assertEquals(1, query.list().size());
  assertEquals(1, query.count());
}
 

@Test
public void testQueryByProcessDefinitionKeyMultipleResults() {
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().processDefinitionKey(PROCESS_DEFINITION_KEY);
  assertEquals(4, query.count());
  assertEquals(4, query.list().size());

  try {
    query.singleResult();
    fail();
  } catch (ProcessEngineException e) {
    // Exception is expected
  }
}
 

@Test
public void testQueryNoSpecificsSingleResult() {
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();
  try {
    query.singleResult();
    fail();
  } catch (ProcessEngineException e) {
    // Exception is expected
  }
}
 

public void testSimpleQueryWithReadInstancesPermissionOnAnyProcessDefinition() {
  // given
  String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
  createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_INSTANCE);

  // when
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessInstance instance = query.singleResult();
  assertNotNull(instance);
  assertEquals(processInstanceId, instance.getId());
}
 

public void testSimpleQueryWithReadInstancesPermissionOnOneTaskProcess() {
  // given
  String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
  createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_INSTANCE);

  // when
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessInstance instance = query.singleResult();
  assertNotNull(instance);
  assertEquals(processInstanceId, instance.getId());
}
 

public void testSimpleQueryWithReadPermissionOnAnyProcessInstance() {
  // given
  String processInstanceId = startProcessInstanceByKey(PROCESS_KEY).getId();
  createGrantAuthorization(PROCESS_INSTANCE, ANY, userId, READ);

  // when
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery();

  // then
  verifyQueryResults(query, 1);

  ProcessInstance instance = query.singleResult();
  assertNotNull(instance);
  assertEquals(processInstanceId, instance.getId());
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryStringVariable() {
  Map<String, Object> vars = new HashMap<>();
  vars.put("stringVar", "abcdef");
  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("stringVar", "abcdef");
  vars.put("stringVar2", "ghijkl");
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("stringVar", "azerty");
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  // Test EQUAL on single string variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("stringVar", "abcdef");
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Test EQUAL on two string variables, should result in single match
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("stringVar", "abcdef").variableValueEquals("stringVar2", "ghijkl");
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Test NOT_EQUAL, should return only 1 resultInstance
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("stringVar", "abcdef").singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN, should return only matching 'azerty'
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("stringVar", "abcdef").singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("stringVar", "z").singleResult();
  assertNull(resultInstance);

  // Test GREATER_THAN_OR_EQUAL, should return 3 results
  assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("stringVar", "abcdef").count());
  assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("stringVar", "z").count());

  // Test LESS_THAN, should return 2 results
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("stringVar", "abcdeg").list();
  Assert.assertEquals(2, processInstances.size());
  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("stringVar", "abcdef").count());
  assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("stringVar", "z").count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("stringVar", "abcdef").list();
  Assert.assertEquals(2, processInstances.size());
  expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("stringVar", "z").count());
  assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("stringVar", "aa").count());

  // Test LIKE
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueLike("stringVar", "azert%").singleResult();
  assertNotNull(resultInstance);
  assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueLike("stringVar", "%y").singleResult();
  assertNotNull(resultInstance);
  assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueLike("stringVar", "%zer%").singleResult();
  assertNotNull(resultInstance);
  assertEquals(processInstance3.getId(), resultInstance.getId());

  assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLike("stringVar", "a%").count());
  assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLike("stringVar", "%x%").count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryLongVariable() {
  Map<String, Object> vars = new HashMap<>();
  vars.put("longVar", 12345L);
  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("longVar", 12345L);
  vars.put("longVar2", 67890L);
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("longVar", 55555L);
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  // Query on single long variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("longVar", 12345L);
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Query on two long variables, should result in single match
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("longVar", 12345L).variableValueEquals("longVar2", 67890L);
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Query with unexisting variable value
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueEquals("longVar", 999L).singleResult();
  assertNull(resultInstance);

  // Test NOT_EQUALS
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("longVar", 12345L).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("longVar", 44444L).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("longVar", 55555L).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("longVar",1L).count());

  // Test GREATER_THAN_OR_EQUAL
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("longVar", 44444L).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("longVar", 55555L).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("longVar",1L).count());

  // Test LESS_THAN
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("longVar", 55555L).list();
  Assert.assertEquals(2, processInstances.size());

  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("longVar", 12345L).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThan("longVar",66666L).count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("longVar", 55555L).list();
  Assert.assertEquals(3, processInstances.size());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("longVar", 12344L).count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryDoubleVariable() {
  Map<String, Object> vars = new HashMap<>();
  vars.put("doubleVar", 12345.6789);
  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("doubleVar", 12345.6789);
  vars.put("doubleVar2", 9876.54321);
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("doubleVar", 55555.5555);
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  // Query on single double variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("doubleVar", 12345.6789);
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Query on two double variables, should result in single value
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("doubleVar", 12345.6789).variableValueEquals("doubleVar2", 9876.54321);
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Query with unexisting variable value
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueEquals("doubleVar", 9999.99).singleResult();
  assertNull(resultInstance);

  // Test NOT_EQUALS
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("doubleVar", 12345.6789).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("doubleVar", 44444.4444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("doubleVar", 55555.5555).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("doubleVar",1.234).count());

  // Test GREATER_THAN_OR_EQUAL
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("doubleVar", 44444.4444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("doubleVar", 55555.5555).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("doubleVar",1.234).count());

  // Test LESS_THAN
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("doubleVar", 55555.5555).list();
  Assert.assertEquals(2, processInstances.size());

  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("doubleVar", 12345.6789).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThan("doubleVar",66666.6666).count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("doubleVar", 55555.5555).list();
  Assert.assertEquals(3, processInstances.size());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("doubleVar", 12344.6789).count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryIntegerVariable() {
  Map<String, Object> vars = new HashMap<>();
  vars.put("integerVar", 12345);
  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("integerVar", 12345);
  vars.put("integerVar2", 67890);
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("integerVar", 55555);
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  // Query on single integer variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("integerVar", 12345);
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Query on two integer variables, should result in single value
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("integerVar", 12345).variableValueEquals("integerVar2", 67890);
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Query with unexisting variable value
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueEquals("integerVar", 9999).singleResult();
  assertNull(resultInstance);

  // Test NOT_EQUALS
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("integerVar", 12345).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("integerVar", 44444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("integerVar", 55555).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("integerVar",1).count());

  // Test GREATER_THAN_OR_EQUAL
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("integerVar", 44444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("integerVar", 55555).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("integerVar",1).count());

  // Test LESS_THAN
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("integerVar", 55555).list();
  Assert.assertEquals(2, processInstances.size());

  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("integerVar", 12345).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThan("integerVar",66666).count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("integerVar", 55555).list();
  Assert.assertEquals(3, processInstances.size());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("integerVar", 12344).count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryShortVariable() {
  Map<String, Object> vars = new HashMap<>();
  short shortVar = 1234;
  vars.put("shortVar", shortVar);
  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  short shortVar2 = 6789;
  vars = new HashMap<>();
  vars.put("shortVar", shortVar);
  vars.put("shortVar2", shortVar2);
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  vars = new HashMap<>();
  vars.put("shortVar", (short)5555);
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  // Query on single short variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("shortVar", shortVar);
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Query on two short variables, should result in single value
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("shortVar", shortVar).variableValueEquals("shortVar2", shortVar2);
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Query with unexisting variable value
  short unexistingValue = (short)9999;
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueEquals("shortVar", unexistingValue).singleResult();
  assertNull(resultInstance);

  // Test NOT_EQUALS
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("shortVar", (short)1234).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("shortVar", (short)4444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("shortVar", (short)5555).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("shortVar",(short)1).count());

  // Test GREATER_THAN_OR_EQUAL
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("shortVar", (short)4444).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("shortVar", (short)5555).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("shortVar",(short)1).count());

  // Test LESS_THAN
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("shortVar", (short)5555).list();
  Assert.assertEquals(2, processInstances.size());

  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("shortVar", (short)1234).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThan("shortVar",(short)6666).count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("shortVar", (short)5555).list();
  Assert.assertEquals(3, processInstances.size());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("shortVar", (short)1233).count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryDateVariable() throws Exception {
  Map<String, Object> vars = new HashMap<>();
  Date date1 = Calendar.getInstance().getTime();
  vars.put("dateVar", date1);

  ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  Date date2 = Calendar.getInstance().getTime();
  vars = new HashMap<>();
  vars.put("dateVar", date1);
  vars.put("dateVar2", date2);
  ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  Calendar nextYear = Calendar.getInstance();
  nextYear.add(Calendar.YEAR, 1);
  vars = new HashMap<>();
  vars.put("dateVar",nextYear.getTime());
  ProcessInstance processInstance3 = runtimeService.startProcessInstanceByKey("oneTaskProcess", vars);

  Calendar nextMonth = Calendar.getInstance();
  nextMonth.add(Calendar.MONTH, 1);

  Calendar twoYearsLater = Calendar.getInstance();
  twoYearsLater.add(Calendar.YEAR, 2);

  Calendar oneYearAgo = Calendar.getInstance();
  oneYearAgo.add(Calendar.YEAR, -1);

  // Query on single short variable, should result in 2 matches
  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().variableValueEquals("dateVar", date1);
  List<ProcessInstance> processInstances = query.list();
  assertNotNull(processInstances);
  Assert.assertEquals(2, processInstances.size());

  // Query on two short variables, should result in single value
  query = runtimeService.createProcessInstanceQuery().variableValueEquals("dateVar", date1).variableValueEquals("dateVar2", date2);
  ProcessInstance resultInstance = query.singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance2.getId(), resultInstance.getId());

  // Query with unexisting variable value
  Date unexistingDate = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss").parse("01/01/1989 12:00:00");
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueEquals("dateVar", unexistingDate).singleResult();
  assertNull(resultInstance);

  // Test NOT_EQUALS
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueNotEquals("dateVar", date1).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  // Test GREATER_THAN
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThan("dateVar", nextMonth.getTime()).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("dateVar", nextYear.getTime()).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThan("dateVar", oneYearAgo.getTime()).count());

  // Test GREATER_THAN_OR_EQUAL
  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("dateVar", nextMonth.getTime()).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  resultInstance = runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("dateVar", nextYear.getTime()).singleResult();
  assertNotNull(resultInstance);
  Assert.assertEquals(processInstance3.getId(), resultInstance.getId());

  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueGreaterThanOrEqual("dateVar",oneYearAgo.getTime()).count());

  // Test LESS_THAN
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThan("dateVar", nextYear.getTime()).list();
  Assert.assertEquals(2, processInstances.size());

  List<String> expecedIds = Arrays.asList(processInstance1.getId(), processInstance2.getId());
  List<String> ids = new ArrayList<>(Arrays.asList(processInstances.get(0).getId(), processInstances.get(1).getId()));
  ids.removeAll(expecedIds);
  assertTrue(ids.isEmpty());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThan("dateVar", date1).count());
  Assert.assertEquals(3, runtimeService.createProcessInstanceQuery().variableValueLessThan("dateVar", twoYearsLater.getTime()).count());

  // Test LESS_THAN_OR_EQUAL
  processInstances = runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("dateVar", nextYear.getTime()).list();
  Assert.assertEquals(3, processInstances.size());

  Assert.assertEquals(0, runtimeService.createProcessInstanceQuery().variableValueLessThanOrEqual("dateVar", oneYearAgo.getTime()).count());

  runtimeService.deleteProcessInstance(processInstance1.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance2.getId(), "test");
  runtimeService.deleteProcessInstance(processInstance3.getId(), "test");
}
 

@Test
@Deployment(resources={"org/camunda/bpm/engine/test/api/oneTaskProcess.bpmn20.xml"})
public void testQueryVariablesUpdatedToNullValue() {
  // Start process instance with different types of variables
  Map<String, Object> variables = new HashMap<>();
  variables.put("longVar", 928374L);
  variables.put("shortVar", (short) 123);
  variables.put("integerVar", 1234);
  variables.put("stringVar", "coca-cola");
  variables.put("dateVar", new Date());
  variables.put("booleanVar", true);
  variables.put("nullVar", null);
  ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", variables);

  ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery()
    .variableValueEquals("longVar", null)
    .variableValueEquals("shortVar", null)
    .variableValueEquals("integerVar", null)
    .variableValueEquals("stringVar", null)
    .variableValueEquals("booleanVar", null)
    .variableValueEquals("dateVar", null);

  ProcessInstanceQuery notQuery = runtimeService.createProcessInstanceQuery()
    .variableValueNotEquals("longVar", null)
    .variableValueNotEquals("shortVar", null)
    .variableValueNotEquals("integerVar", null)
    .variableValueNotEquals("stringVar", null)
    .variableValueNotEquals("booleanVar", null)
    .variableValueNotEquals("dateVar", null);

  assertNull(query.singleResult());
  assertNotNull(notQuery.singleResult());

  // Set all existing variables values to null
  runtimeService.setVariable(processInstance.getId(), "longVar", null);
  runtimeService.setVariable(processInstance.getId(), "shortVar", null);
  runtimeService.setVariable(processInstance.getId(), "integerVar", null);
  runtimeService.setVariable(processInstance.getId(), "stringVar", null);
  runtimeService.setVariable(processInstance.getId(), "dateVar", null);
  runtimeService.setVariable(processInstance.getId(), "nullVar", null);
  runtimeService.setVariable(processInstance.getId(), "booleanVar", null);

  Execution queryResult = query.singleResult();
  assertNotNull(queryResult);
  assertEquals(processInstance.getId(), queryResult.getId());
  assertNull(notQuery.singleResult());
}