mockit.internal.expectations.RecordPhase Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of jmockit Show documentation

JMockit is a Java toolkit for automated developer testing. It contains APIs for the creation of the objects to be tested, for mocking dependencies, and for faking external APIs; JUnit (4 & 5) and TestNG test runners are supported. It also contains an advanced code coverage tool.

The newest version!

/*
 * Copyright (c) 2006 JMockit developers
 * This file is subject to the terms of the MIT license (see LICENSE.txt).
 */
package mockit.internal.expectations;

import static mockit.internal.expectations.state.ExecutingTest.isInstanceMethodWithStandardBehavior;

import edu.umd.cs.findbugs.annotations.NonNull;
import edu.umd.cs.findbugs.annotations.Nullable;

import java.util.Map;

import mockit.internal.expectations.invocation.ExpectedInvocation;

public final class RecordPhase extends TestOnlyPhase {
    RecordPhase(@NonNull PhasedExecutionState executionState) {
        super(executionState);
    }

    void addResult(@Nullable Object result) {
        if (currentExpectation != null) {
            currentExpectation.addResult(result);
        }
    }

    public void addSequenceOfReturnValues(@NonNull Object[] values) {
        if (currentExpectation != null) {
            currentExpectation.addSequenceOfReturnValues(values);
        }
    }

    @Nullable
    @Override
    Object handleInvocation(@Nullable Object mock, int mockAccess, @NonNull String mockClassDesc,
            @NonNull String mockNameAndDesc, @Nullable String genericSignature, boolean withRealImpl,
            @NonNull Object[] args) {
        mock = configureMatchingOnMockInstanceIfSpecified(mock);

        ExpectedInvocation invocation = new ExpectedInvocation(mock, mockAccess, mockClassDesc, mockNameAndDesc,
                matchInstance, genericSignature, args);

        boolean nonStrictInvocation = false;

        if (!matchInstance && invocation.isConstructor()) {
            Map replacementMap = getReplacementMap();
            replacementMap.put(mock, mock);
        } else {
            nonStrictInvocation = isInstanceMethodWithStandardBehavior(mock, mockNameAndDesc);
        }

        currentExpectation = new Expectation(this, invocation, nonStrictInvocation);

        if (argMatchers != null) {
            invocation.arguments.setMatchers(argMatchers);
            argMatchers = null;
        }

        executionState.addExpectation(currentExpectation);

        return invocation.getDefaultValueForReturnType();
    }

    @Nullable
    private Object configureMatchingOnMockInstanceIfSpecified(@Nullable Object mock) {
        matchInstance = false;

        if (mock == null) {
            return null;
        }

        Map replacementMap = getReplacementMap();
        Object replacementInstance = replacementMap.get(mock);
        matchInstance = mock == replacementInstance || isEnumElement(mock);
        return mock;
    }

    @Override
    void handleInvocationCountConstraint(int minInvocations, int maxInvocations) {
        if (currentExpectation != null) {
            currentExpectation.constraints.setLimits(minInvocations, maxInvocations);
        }
    }
}