How to use getMockHandler method of org.mockito.internal.creation.bytebuddy.MockMethodInterceptor class

1package org.mockito.internal.creation.bytebuddy;
2
3import java.io.ObjectStreamException;
4import java.io.Serializable;
5import java.lang.reflect.Method;
6import java.util.concurrent.Callable;
7import org.mockito.internal.InternalMockHandler;
8import org.mockito.internal.creation.DelegatingMethod;
9import org.mockito.internal.invocation.MockitoMethod;
10import org.mockito.internal.invocation.SerializableMethod;
11import org.mockito.internal.progress.SequenceNumber;
12import org.mockito.invocation.MockHandler;
13import org.mockito.mock.MockCreationSettings;
14import net.bytebuddy.implementation.bind.annotation.AllArguments;
15import net.bytebuddy.implementation.bind.annotation.Argument;
16import net.bytebuddy.implementation.bind.annotation.BindingPriority;
17import net.bytebuddy.implementation.bind.annotation.DefaultCall;
18import net.bytebuddy.implementation.bind.annotation.Origin;
19import net.bytebuddy.implementation.bind.annotation.RuntimeType;
20import net.bytebuddy.implementation.bind.annotation.SuperCall;
21import net.bytebuddy.implementation.bind.annotation.This;
22
23public class MockMethodInterceptor implements Serializable {
24
25    private static final long serialVersionUID = 7152947254057253027L;
26
27    private final InternalMockHandler handler;
28    private final MockCreationSettings mockCreationSettings;
29
30    private final ByteBuddyCrossClassLoaderSerializationSupport serializationSupport;
31
32    public MockMethodInterceptor(InternalMockHandler handler, MockCreationSettings mockCreationSettings) {
33        this.handler = handler;
34        this.mockCreationSettings = mockCreationSettings;
35        serializationSupport = new ByteBuddyCrossClassLoaderSerializationSupport();
36    }
37
38    @RuntimeType
39    @BindingPriority(BindingPriority.DEFAULT * 3)
40    public Object interceptSuperCallable(@This Object mock,
41                                         @Origin(cache = true) Method invokedMethod,
42                                         @AllArguments Object[] arguments,
43                                         @SuperCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
44        return doIntercept(
45                mock,
46                invokedMethod,
47                arguments,
48                new InterceptedInvocation.SuperMethod.FromCallable(superCall)
49        );
50    }
51
52    @RuntimeType
53    @BindingPriority(BindingPriority.DEFAULT * 2)
54    public Object interceptDefaultCallable(@This Object mock,
55                                           @Origin(cache = true) Method invokedMethod,
56                                           @AllArguments Object[] arguments,
57                                           @DefaultCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
58        return doIntercept(
59                mock,
60                invokedMethod,
61                arguments,
62                new InterceptedInvocation.SuperMethod.FromCallable(superCall)
63        );
64    }
65
66    @RuntimeType
67    public Object interceptAbstract(@This Object mock,
68                                    @Origin(cache = true) Method invokedMethod,
69                                    @AllArguments Object[] arguments) throws Throwable {
70        return doIntercept(
71                mock,
72                invokedMethod,
73                arguments,
74                InterceptedInvocation.SuperMethod.IsIllegal.INSTANCE
75        );
76    }
77
78    private Object doIntercept(Object mock,
79                               Method invokedMethod,
80                               Object[] arguments,
81                               InterceptedInvocation.SuperMethod superMethod) throws Throwable {
82        return handler.handle(new InterceptedInvocation(
83                mock,
84                createMockitoMethod(invokedMethod),
85                arguments,
86                superMethod,
87                SequenceNumber.next()
88        ));
89    }
90
91    private MockitoMethod createMockitoMethod(Method method) {
92        if (mockCreationSettings.isSerializable()) {
93            return new SerializableMethod(method);
94        } else {
95            return new DelegatingMethod(method);
96        }
97    }
98
99    public MockHandler getMockHandler() {
100        return handler;
101    }
102
103    public ByteBuddyCrossClassLoaderSerializationSupport getSerializationSupport() {
104        return serializationSupport;
105    }
106
107    public static class ForHashCode {
108        public static int doIdentityHashCode(@This Object thiz) {
109            return System.identityHashCode(thiz);
110        }
111    }
112
113    public static class ForEquals {
114        public static boolean doIdentityEquals(@This Object thiz, @Argument(0) Object other) {
115            return thiz == other;
116        }
117    }
118
119    public static class ForWriteReplace {
120        public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamException {
121            return thiz.getMockitoInterceptor().getSerializationSupport().writeReplace(thiz);
122        }
123    }
124
125    public static interface MockAccess {
126        MockMethodInterceptor getMockitoInterceptor();
127        void setMockitoInterceptor(MockMethodInterceptor mockMethodInterceptor);
128    }
129}
130

Source: MockMethodInterceptor.java

package org.mockito.internal.creation.bytebuddy;

import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.concurrent.Callable;
import org.mockito.internal.InternalMockHandler;
import org.mockito.internal.creation.DelegatingMethod;
import org.mockito.internal.invocation.MockitoMethod;
import org.mockito.internal.invocation.SerializableMethod;
import org.mockito.internal.progress.SequenceNumber;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.Argument;
import net.bytebuddy.implementation.bind.annotation.BindingPriority;
import net.bytebuddy.implementation.bind.annotation.DefaultCall;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.SuperCall;
import net.bytebuddy.implementation.bind.annotation.This;

public class MockMethodInterceptor implements Serializable {

    private static final long serialVersionUID = 7152947254057253027L;

    private final InternalMockHandler handler;
    private final MockCreationSettings mockCreationSettings;

    private final ByteBuddyCrossClassLoaderSerializationSupport serializationSupport;

    public MockMethodInterceptor(InternalMockHandler handler, MockCreationSettings mockCreationSettings) {
        this.handler = handler;
        this.mockCreationSettings = mockCreationSettings;
        serializationSupport = new ByteBuddyCrossClassLoaderSerializationSupport();
    }

    @RuntimeType
    @BindingPriority(BindingPriority.DEFAULT * 3)
    public Object interceptSuperCallable(@This Object mock,
                                         @Origin(cache = true) Method invokedMethod,
                                         @AllArguments Object[] arguments,
                                         @SuperCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
        return doIntercept(
                mock,
                invokedMethod,
                arguments,
                new InterceptedInvocation.SuperMethod.FromCallable(superCall)
        );
    }

    @RuntimeType
    @BindingPriority(BindingPriority.DEFAULT * 2)
    public Object interceptDefaultCallable(@This Object mock,
                                           @Origin(cache = true) Method invokedMethod,
                                           @AllArguments Object[] arguments,
                                           @DefaultCall(serializableProxy = true) Callable<?> superCall) throws Throwable {
        return doIntercept(
                mock,
                invokedMethod,
                arguments,
                new InterceptedInvocation.SuperMethod.FromCallable(superCall)
        );
    }

    @RuntimeType
    public Object interceptAbstract(@This Object mock,
                                    @Origin(cache = true) Method invokedMethod,
                                    @AllArguments Object[] arguments) throws Throwable {
        return doIntercept(
                mock,
                invokedMethod,
                arguments,
                InterceptedInvocation.SuperMethod.IsIllegal.INSTANCE
        );
    }

    private Object doIntercept(Object mock,
                               Method invokedMethod,
                               Object[] arguments,
                               InterceptedInvocation.SuperMethod superMethod) throws Throwable {
        return handler.handle(new InterceptedInvocation(
                mock,
                createMockitoMethod(invokedMethod),
                arguments,
                superMethod,
                SequenceNumber.next()
        ));
    }

    private MockitoMethod createMockitoMethod(Method method) {
        if (mockCreationSettings.isSerializable()) {
            return new SerializableMethod(method);
        } else {
            return new DelegatingMethod(method);
        }
    }

    public MockHandler getMockHandler() {
        return handler;
    }

    public ByteBuddyCrossClassLoaderSerializationSupport getSerializationSupport() {
        return serializationSupport;
    }

    public static class ForHashCode {
        public static int doIdentityHashCode(@This Object thiz) {
            return System.identityHashCode(thiz);
        }
    }

    public static class ForEquals {
        public static boolean doIdentityEquals(@This Object thiz, @Argument(0) Object other) {
            return thiz == other;
        }
    }

    public static class ForWriteReplace {
        public static Object doWriteReplace(@This MockAccess thiz) throws ObjectStreamException {
            return thiz.getMockitoInterceptor().getSerializationSupport().writeReplace(thiz);
        }
    }

    public static interface MockAccess {
        MockMethodInterceptor getMockitoInterceptor();
        void setMockitoInterceptor(MockMethodInterceptor mockMethodInterceptor);
    }
}