@Override public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) { T mock = cglibMockMaker.createMock(settings, handler); ClassLoader classLoader = cglibMockMaker.getClass().getClassLoader(); if (classLoader instanceof MockClassLoader) { MockClassLoader mcl = (MockClassLoader) classLoader; // The generated class is not picked up by PowerMock so we cache it here mcl.cache(mock.getClass()); } return mock; }
private MockClassLoader createMockClassLoader(final ByteCodeFramework byteCodeFramework, final String[] classesToLoadByMockClassloader, final UseClassPathAdjuster useClassPathAdjuster, final MockTransformer... extraMockTransformer) { return MockClassLoaderBuilder.create(byteCodeFramework) .forTestClass(testClass) .addIgnorePackage(packagesToIgnore) .addClassesToModify(classesToLoadByMockClassloader) .addClassPathAdjuster(useClassPathAdjuster) .addExtraMockTransformers(extraMockTransformer) .build(); }
private Class<?> defineClass(String name, URL url, final ProtectionDomain protectionDomain) throws IOException { byte[] b = readClass(url); return defineClass(name, b, 0, b.length, protectionDomain); }
public MockClassLoader build() { internalAssertNotNull(testClass, "Test class is null during building classloader. "); final MockClassLoaderConfiguration configuration = new MockClassLoaderConfiguration(classesToModify, packagesToIgnore); final MockClassLoader classLoader = byteCodeFramework.createClassloader(configuration, useClassPathAdjuster); classLoader.setMockTransformerChain(createTransformerChain()); return classLoader; }
@Override protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { Class<?> clazz = findLoadedClass1(name); if (clazz == null) { clazz = loadClass1(name, resolve); } return clazz; } }
private Class<?> loadMockClass(String name, ProtectionDomain protectionDomain) throws ClassNotFoundException { final byte[] clazz = defineAndTransformClass(name, protectionDomain); return defineClass(name, protectionDomain, clazz); }
private ClassLoader createMockClassLoader(final ByteCodeFramework byteCodeFramework, final String[] classesToLoadByMockClassloader, final MockTransformer... extraMockTransformer) { final ClassLoader mockLoader = createWithPrivilegeAccessController(byteCodeFramework, classesToLoadByMockClassloader, extraMockTransformer); initialize(mockLoader); return mockLoader; }
/** * Create an instance of configuration * @param classesToMock classes that should be modified by {@link MockClassLoader}. * @param packagesToDefer classes/packages that should be deferred to system class loader. */ public MockClassLoaderConfiguration(String[] classesToMock, String[] packagesToDefer) { deferPackages = getPackagesToDefer(packagesToDefer); addClassesToModify(classesToMock); }
boolean shouldMockClass(String className) { return shouldModify(className) && !shouldLoadWithMockClassloaderWithoutModifications(className); }
boolean shouldDefer(String className) { return shouldDefer(deferPackages, className); }
public static MockClassLoaderBuilder create(ByteCodeFramework byteCodeFramework) { return new MockClassLoaderBuilder(byteCodeFramework); }
private boolean shouldDefer(String[] packages, String name) { for (String packageToCheck : packages) { if (deferConditionMatches(name, packageToCheck)) { return true; } } return false; }
private boolean isContextClassLoaderShouldBeUsed(String[] classesToLoadByMockClassloader) { return (classesToLoadByMockClassloader == null || classesToLoadByMockClassloader.length == 0) && !hasMockPolicyProvidedClasses(testClass); }
public Class<?> defineClass(final String name, final ProtectionDomain protectionDomain, final byte[] clazz) { return defineClass(name, clazz, 0, clazz.length, protectionDomain); }
public JavassistMockClassLoader(String[] classesToMock, String[] packagesToDefer, UseClassPathAdjuster useClassPathAdjuster) { this(new MockClassLoaderConfiguration(classesToMock, packagesToDefer), useClassPathAdjuster); }
private boolean shouldIgnore(String className) { return shouldIgnore(deferPackages, className); }
private MockClassLoaderBuilder(final ByteCodeFramework byteCodeFramework) { this.byteCodeFramework = byteCodeFramework; transformerChainFactory = byteCodeFramework.createTransformerChainFactory(); extraMockTransformers = new ArrayList<MockTransformer>(); }
if (classLoader instanceof MockClassLoader) { MockClassLoader mcl = (MockClassLoader) classLoader; mcl.cache(mock.getClass());
private boolean shouldDefer(String name) { return configuration.shouldDefer(name); }
private void cacheMockClass(final Class<?> mockClass) { ClassLoader classLoader = mockClass.getClassLoader(); if (classLoader instanceof MockClassLoader) { MockClassLoader mcl = (MockClassLoader) classLoader; mcl.cache(mockClass); } }