private void initialize(final ClassLoader mockLoader) { new MockPolicyInitializerImpl(testClass).initialize(mockLoader); }
public MockPolicyInitializerImpl(Class<?> testClass) { this(getMockPolicies(testClass), testClass, false); }
private void initialize(MockClassLoader classLoader) { if (mockPolicies.length > 0) { updateClassLoaderConfiguration(classLoader.getConfiguration()); invokeInitializeInterceptionSettingsFromClassLoader(classLoader); } }
/** * @return {@code true} if there are some mock policies that * contributes with classes that should be loaded by the mock * classloader, {@code false} otherwise. */ private boolean hasMockPolicyProvidedClasses(Class<?> testClass) { boolean hasMockPolicyProvidedClasses = false; if (testClass.isAnnotationPresent(MockPolicy.class)) { MockPolicy annotation = testClass.getAnnotation(MockPolicy.class); Class<? extends PowerMockPolicy>[] value = annotation.value(); hasMockPolicyProvidedClasses = new MockPolicyInitializerImpl(value).needsInitialization(); } return hasMockPolicyProvidedClasses; } }
protected void init(Object target) { final Class<?> testClass = target.getClass(); try { mockPolicyInitializer = new MockPolicyInitializerImpl(testClass); testSuiteChunker = new PowerMockRuleTestSuiteChunker(testClass); previousTargetClass = target.getClass(); } catch (Exception e) { throw new RuntimeException(e); } } }
@Override public void initialize(ClassLoader classLoader) { if (classLoader instanceof MockClassLoader) { initialize(((MockClassLoader) classLoader)); } }
@Override public boolean isPrepared(String fullyQualifiedClassName) { MockPolicyClassLoadingSettings settings = getClassLoadingSettings(); final boolean foundInSuppressStaticInitializer = Arrays.binarySearch(settings.getStaticInitializersToSuppress(), fullyQualifiedClassName) < 0; final boolean foundClassesLoadedByMockClassloader = Arrays.binarySearch(settings.getFullyQualifiedNamesOfClassesToLoadByMockClassloader(), fullyQualifiedClassName) < 0; return foundInSuppressStaticInitializer || foundClassesLoadedByMockClassloader; }
@Override public void refreshPolicies(ClassLoader classLoader) { if (classLoader instanceof MockClassLoader) { invokeInitializeInterceptionSettingsFromClassLoader((MockClassLoader) classLoader); } }
@SuppressWarnings("unused") private void initializeInterceptionSettings() { MockPolicyInterceptionSettings interceptionSettings = getInterceptionSettings(); for (Method method : interceptionSettings.getMethodsToSuppress()) { MockRepository.addMethodToSuppress(method); } for (Entry<Method, InvocationHandler> entry : interceptionSettings.getProxiedMethods().entrySet()) { MockRepository.putMethodProxy(entry.getKey(), entry.getValue()); } for (Entry<Method, Object> entry : interceptionSettings.getStubbedMethods().entrySet()) { final Method method = entry.getKey(); final Object className = entry.getValue(); MockRepository.putMethodToStub(method, className); } for (Field field : interceptionSettings.getFieldsToSuppress()) { MockRepository.addFieldToSuppress(field); } for (String type : interceptionSettings.getFieldTypesToSuppress()) { MockRepository.addFieldTypeToSuppress(type); } }
@Override public boolean needsInitialization() { MockPolicyClassLoadingSettings settings = getClassLoadingSettings(); return settings.getStaticInitializersToSuppress().length > 0 || settings.getFullyQualifiedNamesOfClassesToLoadByMockClassloader().length > 0; }
private void initializeMockPolicy() {new MockPolicyInitializerImpl(testClass).initialize(mockLoader);}
private void updateClassLoaderConfiguration(MockClassLoaderConfiguration configuration) { MockPolicyClassLoadingSettings classLoadingSettings = getClassLoadingSettings(); String[] fullyQualifiedNamesOfClassesToLoadByMockClassloader = classLoadingSettings.getFullyQualifiedNamesOfClassesToLoadByMockClassloader(); configuration.addClassesToModify(fullyQualifiedNamesOfClassesToLoadByMockClassloader); if (testClass == null) { throw new IllegalStateException("Internal error: testClass should never be null when calling initialize on a mock policy"); } configuration.addClassesToModify(testClass.getName()); Class<?>[] classes = testClass.getDeclaredClasses(); for (Class<?> clazz : classes) { configuration.addClassesToModify(clazz.getName()); } Class<?>[] declaredClasses = testClass.getClasses(); for (Class<?> clazz : declaredClasses) { configuration.addClassesToModify(clazz.getName()); } for (String string : classLoadingSettings.getStaticInitializersToSuppress()) { configuration.addClassesToModify(string); MockRepository.addSuppressStaticInitializer(string); } }
public static void initialize(Class<?> testClass, JavaAgentClassRegister agentClassRegister) { /* * For extra safety clear the MockitoRepository. */ MockRepository.clear(); redefineClasses(testClass, agentClassRegister); final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); new MockPolicyInitializerImpl(testClass).initialize(contextClassLoader); }
public void run(TestResult result) { final Iterator<TestChunk> iterator = getChunkIterator(); for (PowerMockJUnit3RunnerDelegate delegate : delegates) { TestChunk next = iterator.next(); final PowerMockJUnit3TestListener listener = new PowerMockJUnit3TestListener(next.getClassLoader()); result.addListener(listener); // Initialize mock policies for each test new MockPolicyInitializerImpl(delegate.getTestClass()).initialize(this.getClass().getClassLoader()); delegate.run(result); result.removeListener(listener); } }