public boolean isTypeMockable(Class<?> clz) { return ClassImposterizer.INSTANCE.canImposterise(clz); }
public static ClassLoader combineLoadersOf(Class<?>... classes) { return combineLoadersOf(classes[0], classes); }
public <T> T imposterise(final MethodInterceptor interceptor, Class<T> mockedType, Collection<Class> ancillaryTypes) { return imposterise(interceptor, mockedType, ancillaryTypes.toArray(new Class[ancillaryTypes.size()])); }
@Override @SuppressWarnings("unchecked") public <T> T createProxy(Class<?> targetClass, MethodInterceptor interceptor) { // can we subclass the class of the target? if (!ClassImposterizer.INSTANCE.canImposterise(targetClass)) { // delegate return fallbackProxyFactory.<T> createProxy(targetClass, interceptor); } // create proxy T proxy; try { proxy = (T) ClassImposterizer.INSTANCE.imposterise(interceptor, targetClass); } catch (MockitoException e) { // delegate return fallbackProxyFactory.<T> createProxy(targetClass, interceptor); } return proxy; } }
public <T> T imposterise(final MethodInterceptor interceptor, Class<T> mockedType, Class<?>... ancillaryTypes) { try { setConstructorsAccessible(mockedType, true); Class<?> proxyClass = createProxyClass(mockedType, ancillaryTypes); return mockedType.cast(createProxy(proxyClass, interceptor)); } catch (ClassCastException cce) { throw new MockitoException(join( "ClassCastException occurred when creating the proxy.", "You might experience classloading issues, disabling the Objenesis cache *might* help (see MockitoConfiguration)" ), cce); } finally { setConstructorsAccessible(mockedType, false); } }
private static ClassLoader combineLoadersOf(Class<?> first, Class<?>... others) { List<ClassLoader> loaders = new ArrayList<ClassLoader>(); addIfNewElement(loaders, first.getClassLoader()); for (Class<?> c : others) { addIfNewElement(loaders, c.getClassLoader()); } // To support Eclipse Plug-in tests. // In an Eclipse plug-in, jMock itself will not be on the system class loader // but in the class loader of the plug-in. // // Note: I've been unable to reproduce the error in jMock's test suite. addIfNewElement(loaders, SearchingClassLoader.class.getClassLoader()); // To support the Maven Surefire plugin. // Note: I've been unable to reproduce the error in jMock's test suite. addIfNewElement(loaders, currentThread().getContextClassLoader()); //Had to comment that out because it didn't work with in-container Spring tests //addIfNewElement(loaders, ClassLoader.getSystemClassLoader()); return combine(loaders); }
enhancer.setClassLoader(SearchingClassLoader.combineLoadersOf(mockedType)); enhancer.setUseFactory(true); if (mockedType.isInterface()) { enhancer.setSuperclass(Object.class); enhancer.setInterfaces(prepend(mockedType, interfaces)); } else { enhancer.setSuperclass(mockedType);
private static ClassLoader combine(List<ClassLoader> parentLoaders) { ClassLoader loader = parentLoaders.get(parentLoaders.size()-1); for (int i = parentLoaders.size()-2; i >= 0; i--) { loader = new SearchingClassLoader(parentLoaders.get(i), loader); } return loader; }
@SuppressWarnings("unchecked") public <T> T createProxy(Class<?> targetClass, MethodInterceptor interceptor) { // can we subclass the class of the target? if (!ClassImposterizer.INSTANCE.canImposterise(targetClass)) { // delegate return fallbackProxyFactory.<T> createProxy(targetClass, interceptor); } // create proxy T proxy; try { proxy = (T) ClassImposterizer.INSTANCE.imposterise(interceptor, targetClass); } catch (MockitoException e) { // delegate return fallbackProxyFactory.<T> createProxy(targetClass, interceptor); } return proxy; } }
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) { InternalMockHandler mockitoHandler = cast(handler); return ClassImposterizer.INSTANCE.imposterise( new MethodInterceptorFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces()); }
public <T> T imposterise(final MethodInterceptor interceptor, Class<T> mockedType, Class<?>... ancillaryTypes) { try { setConstructorsAccessible(mockedType, true); Class<?> proxyClass = createProxyClass(mockedType, ancillaryTypes); return mockedType.cast(createProxy(proxyClass, interceptor)); } finally { setConstructorsAccessible(mockedType, false); } }
Object returnValueFor(Class<?> clazz) { if (!ClassImposterizer.INSTANCE.canImposterise(clazz)) { return null; } return mockitoCore.mock(clazz, new MockSettingsImpl().defaultAnswer(this)); } }
public static ClassLoader combineLoadersOf(Class<?>... classes) { return combineLoadersOf(classes[0], classes); }
private static ClassLoader combine(List<ClassLoader> parentLoaders) { ClassLoader loader = parentLoaders.get(parentLoaders.size()-1); for (int i = parentLoaders.size()-2; i >= 0; i--) { loader = new SearchingClassLoader(parentLoaders.get(i), loader); } return loader; }
public Object answer(final InvocationOnMock invocation) throws Throwable { Object defaultReturnValue = delegate.answer(invocation); if (defaultReturnValue != null) { return defaultReturnValue; } Class<?> type = invocation.getMethod().getReturnType(); if (ClassImposterizer.INSTANCE.canImposterise(type)) { return ClassImposterizer.INSTANCE.imposterise(new ThrowingInterceptor(invocation), type); } return null; } }
private T getMockWithSynchronizedMethodIntercepting() { SynchronizedMockMethodInterceptorFilter synchronizedMethodInterceptorFilter = createSynchronizedMethodInterceptorFilter(); return ClassImposterizer.INSTANCE.imposterise(synchronizedMethodInterceptorFilter, mockClass, new Class[0]); }
public boolean isTypeMockable(Class<?> clz) { return ClassImposterizer.INSTANCE.canImposterise(clz); }
/** * Verifies certain behaviour of all the mocks in the {@link Collection} occurs. Amongst others, the * {@link VerificationMode} can be specified using {@link Mockito#times(int)}, {@link Mockito#never()}, * {@link Mockito#atLeast(int)}, {@link Mockito#atLeastOnce()}, {@link Mockito#atMost(int)}, and * {@link Mockito#only()} (only acts slightly differently). For example: * * <pre class="code"> * <code class="java"> * collectiveVerify(SomeClass.class, collectionOfMocks, times(3)).method("arg"); * collectiveVerify(SomeClass.class, collectionOfMocks, never()).otherMethod("other arg"); * collectiveVerify(SomeClass.class, collectionOfMocks, only()).anotherMethod("another arg"); * </code> * </pre> * * @see #collectiveVerify(Class, Collection) * @see Mockito#verify(Object, VerificationMode) * @param mockClass * @param collection * @param mode * @return Object used for verification of all the mocks in the supplied collection */ public <T> T collectiveVerify(Class<T> mockClass, Collection<T> collection, VerificationMode mode) { MethodInterceptor interceptor = new CollectiveVerifyMethodInterceptor(collection, mode); T verifier = ClassImposterizer.INSTANCE.imposterise(interceptor, mockClass); return verifier; }
Object returnValueFor(Class<?> clazz) { if (!ClassImposterizer.INSTANCE.canImposterise(clazz)) { return null; } return mockitoCore.mock(clazz, new MockSettingsImpl().defaultAnswer(this)); } }
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) { InternalMockHandler mockitoHandler = cast(handler); return ClassImposterizer.INSTANCE.imposterise( new MethodInterceptorForGroovyFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces()); }