package org.jmock.imposters;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import org.jmock.api.Imposteriser;
import org.jmock.api.Invocation;
import org.jmock.api.Invokable;
import org.jmock.internal.SearchingClassLoader;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.NamingStrategy;
import net.bytebuddy.description.modifier.Visibility;
import net.bytebuddy.dynamic.DynamicType.Builder;
import net.bytebuddy.dynamic.loading.ClassInjector;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.FieldAccessor;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.implementation.bind.annotation.AllArguments;
import net.bytebuddy.implementation.bind.annotation.FieldValue;
import net.bytebuddy.implementation.bind.annotation.Origin;
import net.bytebuddy.implementation.bind.annotation.RuntimeType;
import net.bytebuddy.implementation.bind.annotation.This;
import net.bytebuddy.matcher.ElementMatchers;
/**
* This class lets you imposterise abstract and concrete classes
* without calling the constructors of the mocked class.
*
* @author olibye
*/
public class ByteBuddyClassImposteriser implements Imposteriser {
public static final Imposteriser INSTANCE = new ByteBuddyClassImposteriser();
private static final String JMOCK_KEY = "jMock";
private final Objenesis objenesis = new ObjenesisStd();
private final Map>, Class>> types = new ConcurrentHashMap>, Class>>();
private ByteBuddyClassImposteriser() {
}
public boolean canImposterise(Class> type) {
return !type.isPrimitive() &&
!Modifier.isFinal(type.getModifiers()) &&
(type.isInterface() || !toStringMethodIsFinal(type));
}
@Override
public T imposterise(final Invokable mockObject, Class mockedType, Class>... ancilliaryTypes) {
if (!mockedType.isInterface() && toStringMethodIsFinal(mockedType)) {
throw new IllegalArgumentException(mockedType.getName() + " has a final toString method");
}
try {
setConstructorsAccessible(mockedType, true);
return proxy(mockObject, mockedType, ancilliaryTypes);
} finally {
setConstructorsAccessible(mockedType, false);
}
}
private boolean toStringMethodIsFinal(Class> type) {
try {
Method toString = type.getMethod("toString");
return Modifier.isFinal(toString.getModifiers());
} catch (SecurityException e) {
throw new IllegalStateException("not allowed to reflect on toString method", e);
} catch (NoSuchMethodException e) {
throw new Error("no public toString method found", e);
}
}
private void setConstructorsAccessible(Class> mockedType, boolean accessible) {
for (Constructor> constructor : mockedType.getDeclaredConstructors()) {
constructor.setAccessible(accessible);
}
}
private T proxy(
final Invokable mockObject, final Class mockedType, final Class>... ancilliaryTypes) {
try {
Set> mockTypeKey = mockTypeKey(mockedType, ancilliaryTypes);
Class> proxyType = types.computeIfAbsent(mockTypeKey,
new Function