MultiInstanceHandler (bpmn-driven-testing-impl 0.6.0 API)

java.lang.Object
- org.camunda.community.bpmndt.api.MultiInstanceHandler<T,U>

Type Parameters:

T - The generated multi instance handler type.

U - The activity handler type (e.g. UserTaskHandler).
```
public class MultiInstanceHandler<T extends MultiInstanceHandler<?,?>,U>
extends Object
```
Fluent API for multi instance activites (call activities or tasks). This class does not support multi instances scopes like sub processes or transactions.

Field Summary

Fields
Modifier and Type Field and Description

protected TestCaseInstance instance

Fields
Modifier and Type	Field and Description
`protected TestCaseInstance`	`instance`

Constructor Summary

Constructors
Constructor and Description

MultiInstanceHandler(TestCaseInstance instance, String activityId)

Constructors
Constructor and Description
`MultiInstanceHandler(TestCaseInstance instance, String activityId)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`apply(org.camunda.bpm.engine.runtime.ProcessInstance pi)`
`protected boolean`	`apply(org.camunda.bpm.engine.runtime.ProcessInstance pi, int loopIndex)` Applies the multi instance loop for the given index.
`protected U`	`createHandler(int loopIndex)` Creates a new activity handler.
`protected JobHandler`	`createHandlerAfter(int loopIndex)` Creates a new job handler for the asynchronous continuation after the activity.
`protected JobHandler`	`createHandlerBefore(int loopIndex)` Creates a new job handler for the asynchronous continuation before the activity.
`T`	`customize(Consumer<MultiInstanceHandler<T,U>> customizer)` Customizes the handler, using the given `Consumer` function.
`protected U`	`getHandler(int loopIndex)`
`protected JobHandler`	`getHandlerAfter(int loopIndex)`
`protected JobHandler`	`getHandlerBefore(int loopIndex)`
`protected org.camunda.bpm.engine.ProcessEngine`	`getProcessEngine()`
`U`	`handle()` Returns the default activity handler, which is used when for a multi instance loop with a specific index no handler is defined.
`U`	`handle(int loopIndex)` Returns the activity handler, which is applied on the multi instance loop with the given index.
`JobHandler`	`handleAfter()` Returns the default job handler for the asynchronous continuation after the activity, which is used when for a multi instance loop with a specific index no handler is defined.
`JobHandler`	`handleAfter(int loopIndex)` Returns the job handler for the asynchronous continuation after the activity, which is applied on the multi instance loop with the given index.
`JobHandler`	`handleBefore()` Returns the default job handler for the asynchronous continuation before the activity, which is used when for a multi instance loop with a specific index no handler is defined.
`JobHandler`	`handleBefore(int loopIndex)` Returns the job handler for the asynchronous continuation before the activity, which is applied on the multi instance loop with the given index.
`protected boolean`	`isEnded(org.camunda.bpm.engine.runtime.ProcessInstance pi)` Checks if the multi instance scope is ended or not.
`protected boolean`	`isSequential()` Determines if the multi instance loop is sequentially executed or not.
`protected void`	`registerCallActivityHandler(CallActivityHandler handler)` Registers the given call activity handler at the test case instance, so that it will be executed when the custom call activity behavior is applied. Since there can be multiple handlers (one for each loop index), it is necessary to register the correct one before the next multi instance loop is executed.
`T`	`verifyLoopCount(int loopCount)` Verifies that the multi instance loop is executed n-times.
`T`	`verifyParallel()` Verifies that the multi instance loop execution is done in parallel.
`T`	`verifySequential()` Verifies that the multi instance loop is sequentially executed.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - instance
```
protected final TestCaseInstance instance
```
- Constructor Detail
  - MultiInstanceHandler
```
public MultiInstanceHandler(TestCaseInstance instance,
                            String activityId)
```
- Method Detail
  - apply
```
protected void apply(org.camunda.bpm.engine.runtime.ProcessInstance pi)
```
  - apply
```
protected boolean apply(org.camunda.bpm.engine.runtime.ProcessInstance pi,
                        int loopIndex)
```
    Applies the multi instance loop for the given index. Please note: This method will be overriden by generated multi instance handler classes in case of call activities, external tasks and user tasks.
    
    Parameters:
    
    pi - The process instance, used to execute the test case.
    
    loopIndex - The current loop index.
    
    Returns:
    
    true, if the multi instance execution should be continued. Otherwise false.
  - createHandler
```
protected U createHandler(int loopIndex)
```
    Creates a new activity handler. Please note: This method will be overridden by generated multi instance handler classes.
    
    Parameters:
    
    loopIndex - The current loop index.
    
    Returns:
    
    The newly created handler.
  - createHandlerAfter
```
protected JobHandler createHandlerAfter(int loopIndex)
```
    Creates a new job handler for the asynchronous continuation after the activity.
    
    Parameters:
    
    loopIndex - The current loop index.
    
    Returns:
    
    The newly created job handler.
  - createHandlerBefore
```
protected JobHandler createHandlerBefore(int loopIndex)
```
    Creates a new job handler for the asynchronous continuation before the activity.
    
    Parameters:
    
    loopIndex - The current loop index.
    
    Returns:
    
    The newly created job handler.
  - customize
```
public T customize(Consumer<MultiInstanceHandler<T,U>> customizer)
```
    Customizes the handler, using the given Consumer function. This method can be used to apply a common customization needed for different test cases.
```
 tc.handleMultiInstance().customize(this::prepareMultiInstance);
 
```
    Parameters:
    
    customizer - A function that accepts a suitable MultiInstanceHandler.
    
    Returns:
    
    The handler.
  - getHandler
```
protected U getHandler(int loopIndex)
```
  - getHandlerAfter
```
protected JobHandler getHandlerAfter(int loopIndex)
```
  - getHandlerBefore
```
protected JobHandler getHandlerBefore(int loopIndex)
```
  - getProcessEngine
```
protected org.camunda.bpm.engine.ProcessEngine getProcessEngine()
```
  - handle
```
public U handle()
```
    Returns the default activity handler, which is used when for a multi instance loop with a specific index no handler is defined.
    
    Returns:
    
    The default handler.
  - handle
```
public U handle(int loopIndex)
```
    Returns the activity handler, which is applied on the multi instance loop with the given index.
    
    Parameters:
    
    loopIndex - A specific loop index.
    
    Returns:
    
    The handler for the given loop index.
  - handleAfter
```
public JobHandler handleAfter()
```
    Returns the default job handler for the asynchronous continuation after the activity, which is used when for a multi instance loop with a specific index no handler is defined.
    
    Returns:
    
    The default async after job handler.
  - handleAfter
```
public JobHandler handleAfter(int loopIndex)
```
    Returns the job handler for the asynchronous continuation after the activity, which is applied on the multi instance loop with the given index. This handler can be used to verify the process variables after the activity was executed the nth time.
    
    Parameters:
    
    loopIndex - A specific loop index.
    
    Returns:
    
    The async after job handler for the given loop index.
  - handleBefore
```
public JobHandler handleBefore()
```
    Returns the default job handler for the asynchronous continuation before the activity, which is used when for a multi instance loop with a specific index no handler is defined.
    
    Returns:
    
    The default async before job handler.
  - handleBefore
```
public JobHandler handleBefore(int loopIndex)
```
    Returns the job handler for the asynchronous continuation before the activity, which is applied on the multi instance loop with the given index. This handler can be used to verify the process variables before the activity is executed the nth time.
    
    Parameters:
    
    loopIndex - A specific loop index.
    
    Returns:
    
    The async before job handler for the given loop index.
  - isEnded
```
protected boolean isEnded(org.camunda.bpm.engine.runtime.ProcessInstance pi)
```
    Checks if the multi instance scope is ended or not.
    
    Parameters:
    
    pi - The related process instance.
    
    Returns:
    
    true, if the multi instance scope is ended. Otherwise false.
  - isSequential
```
protected boolean isSequential()
```
    Determines if the multi instance loop is sequentially executed or not. Please note: If the multi instance loop is defined as parallel, this method will be overridden by generated multi instance handler classes.
    
    Returns:
    
    true, if execution is done sequentially. false, if execution is done in parallel.
  - registerCallActivityHandler
```
protected void registerCallActivityHandler(CallActivityHandler handler)
```
    Registers the given call activity handler at the test case instance, so that it will be executed when the custom call activity behavior is applied.
    Since there can be multiple handlers (one for each loop index), it is necessary to register the correct one before the next multi instance loop is executed.
    
    Parameters:
    
    handler - The handler to be executed next.
  - verifyLoopCount
```
public T verifyLoopCount(int loopCount)
```
    Verifies that the multi instance loop is executed n-times.
    
    Parameters:
    
    loopCount - The expected loop count at the point of time when the multi instance is left (finished or terminated by a boundary event).
    
    Returns:
    
    The handler.
  - verifyParallel
```
public T verifyParallel()
```
    Verifies that the multi instance loop execution is done in parallel.
    
    Returns:
    
    The handler.
  - verifySequential
```
public T verifySequential()
```
    Verifies that the multi instance loop is sequentially executed.
    
    Returns:
    
    The handler.

Class MultiInstanceHandler<T extends MultiInstanceHandler<?,?>,U>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

instance

Constructor Detail

MultiInstanceHandler

Method Detail

apply

apply

createHandler

createHandlerAfter

createHandlerBefore

customize

getHandler

getHandlerAfter

getHandlerBefore

getProcessEngine

handle

handle

handleAfter

handleAfter

handleBefore

handleBefore

isEnded

isSequential

registerCallActivityHandler

verifyLoopCount

verifyParallel

verifySequential