org.mockito.internal.configuration.injection

Class MockInjectionStrategy

java.lang.Object

org.mockito.internal.configuration.injection.MockInjectionStrategy

Direct Known Subclasses:

ConstructorInjection, PropertyAndSetterInjection, SpyOnInjectedFieldsHandler

public abstract class MockInjectionStrategy
extends java.lang.Object

Injector strategy contract

Field Summary

Fields

Modifier and Type	Field and Description
private MockInjectionStrategy	nextStrategy

Constructor Summary

Constructors

Constructor and Description
MockInjectionStrategy()

Method Summary

Modifier and Type	Method and Description
static MockInjectionStrategy	nop() NOP Strategy that will always try the next strategy.
boolean	process(java.lang.reflect.Field onField, java.lang.Object fieldOwnedBy, java.util.Set<java.lang.Object> mockCandidates) Actually inject mockCandidates on field.
protected abstract boolean	processInjection(java.lang.reflect.Field field, java.lang.Object fieldOwner, java.util.Set<java.lang.Object> mockCandidates) Process actual injection.
private boolean	relayProcessToNextStrategy(java.lang.reflect.Field field, java.lang.Object fieldOwner, java.util.Set<java.lang.Object> mockCandidates)
MockInjectionStrategy	thenTry(MockInjectionStrategy strategy) Enqueue next injection strategy.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

nextStrategy

private MockInjectionStrategy nextStrategy

Constructor Detail

MockInjectionStrategy

public MockInjectionStrategy()

Method Detail

nop

public static MockInjectionStrategy nop()

NOP Strategy that will always try the next strategy.

thenTry

public MockInjectionStrategy thenTry(MockInjectionStrategy strategy)

Enqueue next injection strategy.

The implementation should take care of the actual calling if required.

Parameters:

strategy - Queued strategy.

Returns:

The passed strategy instance to allow chaining.

process

public boolean process(java.lang.reflect.Field onField,
                       java.lang.Object fieldOwnedBy,
                       java.util.Set<java.lang.Object> mockCandidates)

Actually inject mockCandidates on field.

Actual algorithm is defined in the implementations of processInjection(Field, Object, Set). However if injection occurred successfully, the process should return true, and false otherwise.

The code takes care of calling the next strategy if available and if of course if required

Parameters:

onField - Field needing injection.

fieldOwnedBy - The owning instance of the field.

mockCandidates - A set of mock candidate, that might be injected.

Returns:

true if successful, false otherwise.

processInjection

protected abstract boolean processInjection(java.lang.reflect.Field field,
                                            java.lang.Object fieldOwner,
                                            java.util.Set<java.lang.Object> mockCandidates)

Process actual injection.

Don't call this method directly, instead call process(Field, Object, Set)

Parameters:

field - Field needing injection

fieldOwner - Field owner instance.

mockCandidates - Pool of mocks to inject.

Returns:

true if injection occurred, false otherwise

relayProcessToNextStrategy

private boolean relayProcessToNextStrategy(java.lang.reflect.Field field,
                                           java.lang.Object fieldOwner,
                                           java.util.Set<java.lang.Object> mockCandidates)