How to use RealMethod class of org.mockito.internal.invocation package

1/*
2 * Copyright (c) 2017 Mockito contributors
3 * This program is made available under the terms of the MIT License.
4 */
5package org.mockito.internal.invocation;
6
7import java.lang.reflect.Method;
8import java.util.concurrent.Callable;
9
10import org.mockito.internal.creation.DelegatingMethod;
11import org.mockito.internal.debugging.LocationImpl;
12import org.mockito.internal.invocation.mockref.MockWeakReference;
13import org.mockito.internal.progress.SequenceNumber;
14import org.mockito.invocation.Invocation;
15import org.mockito.invocation.InvocationFactory;
16import org.mockito.invocation.Location;
17import org.mockito.mock.MockCreationSettings;
18
19public class DefaultInvocationFactory implements InvocationFactory {
20
21    public Invocation createInvocation(
22            Object target,
23            MockCreationSettings settings,
24            Method method,
25            final Callable realMethod,
26            Object... args) {
27        RealMethod superMethod = new RealMethod.FromCallable(realMethod);
28        return createInvocation(target, settings, method, superMethod, args);
29    }
30
31    public Invocation createInvocation(
32            Object target,
33            MockCreationSettings settings,
34            Method method,
35            RealMethodBehavior realMethod,
36            Object... args) {
37        RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
38        return createInvocation(target, settings, method, superMethod, args);
39    }
40
41    private Invocation createInvocation(
42            Object target,
43            MockCreationSettings settings,
44            Method method,
45            RealMethod superMethod,
46            Object[] args) {
47        return createInvocation(target, method, args, superMethod, settings);
48    }
49
50    public static InterceptedInvocation createInvocation(
51            Object mock,
52            Method invokedMethod,
53            Object[] arguments,
54            RealMethod realMethod,
55            MockCreationSettings settings,
56            Location location) {
57        return new InterceptedInvocation(
58                new MockWeakReference<Object>(mock),
59                createMockitoMethod(invokedMethod, settings),
60                arguments,
61                realMethod,
62                location,
63                SequenceNumber.next());
64    }
65
66    private static InterceptedInvocation createInvocation(
67            Object mock,
68            Method invokedMethod,
69            Object[] arguments,
70            RealMethod realMethod,
71            MockCreationSettings settings) {
72        return createInvocation(
73                mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
74    }
75
76    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
77        if (settings.isSerializable()) {
78            return new SerializableMethod(method);
79        } else {
80            return new DelegatingMethod(method);
81        }
82    }
83}
84

Source: DefaultInvocationFactory.java

/*
 * Copyright (c) 2017 Mockito contributors
 * This program is made available under the terms of the MIT License.
 */
package org.mockito.internal.invocation;

import java.lang.reflect.Method;
import java.util.concurrent.Callable;

import org.mockito.internal.creation.DelegatingMethod;
import org.mockito.internal.debugging.LocationImpl;
import org.mockito.internal.invocation.mockref.MockWeakReference;
import org.mockito.internal.progress.SequenceNumber;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationFactory;
import org.mockito.invocation.Location;
import org.mockito.mock.MockCreationSettings;

public class DefaultInvocationFactory implements InvocationFactory {

    public Invocation createInvocation(
            Object target,
            MockCreationSettings settings,
            Method method,
            final Callable realMethod,
            Object... args) {
        RealMethod superMethod = new RealMethod.FromCallable(realMethod);
        return createInvocation(target, settings, method, superMethod, args);
    }

    public Invocation createInvocation(
            Object target,
            MockCreationSettings settings,
            Method method,
            RealMethodBehavior realMethod,
            Object... args) {
        RealMethod superMethod = new RealMethod.FromBehavior(realMethod);
        return createInvocation(target, settings, method, superMethod, args);
    }

    private Invocation createInvocation(
            Object target,
            MockCreationSettings settings,
            Method method,
            RealMethod superMethod,
            Object[] args) {
        return createInvocation(target, method, args, superMethod, settings);
    }

    public static InterceptedInvocation createInvocation(
            Object mock,
            Method invokedMethod,
            Object[] arguments,
            RealMethod realMethod,
            MockCreationSettings settings,
            Location location) {
        return new InterceptedInvocation(
                new MockWeakReference<Object>(mock),
                createMockitoMethod(invokedMethod, settings),
                arguments,
                realMethod,
                location,
                SequenceNumber.next());
    }

    private static InterceptedInvocation createInvocation(
            Object mock,
            Method invokedMethod,
            Object[] arguments,
            RealMethod realMethod,
            MockCreationSettings settings) {
        return createInvocation(
                mock, invokedMethod, arguments, realMethod, settings, new LocationImpl());
    }

    private static MockitoMethod createMockitoMethod(Method method, MockCreationSettings settings) {
        if (settings.isSerializable()) {
            return new SerializableMethod(method);
        } else {
            return new DelegatingMethod(method);
        }
    }
}