@Override public void withArguments(Object firstArgument, Object... additionalArguments) throws Exception { if (additionalArguments == null || additionalArguments.length == 0) { method.invoke(objectToVerify, firstArgument); } else { Object[] arguments = new ArrayMergerImpl().mergeArrays(Object.class, new Object[]{firstArgument}, additionalArguments); method.invoke(objectToVerify, arguments); } }
public MockClassLoaderFactory(Class<?> testClass, String[] packagesToIgnore) { this.testClass = testClass; this.prepareForTestExtractor = new PrepareForTestExtractorImpl(); this.suppressionExtractor = new StaticConstructorSuppressExtractorImpl(); this.packagesToIgnore = packagesToIgnore; arrayMerger = new ArrayMergerImpl(); }
private void initEntries(List<TestCaseEntry> entries) { for (TestCaseEntry testCaseEntry : entries) { final Class<?> testClass = testCaseEntry.getTestClass(); findMethods(testCaseEntry, testClass); } }
TestNGMockClassLoaderFactory() { ignorePackagesExtractor = new PowerMockIgnorePackagesExtractorImpl(); expectedExceptionsExtractor = new PowerMockExpectedExceptionsExtractorImpl(); arrayMerger = new ArrayMergerImpl(); }
private void initialize(final ClassLoader mockLoader) { new MockPolicyInitializerImpl(testClass).initialize(mockLoader); }
public AbstractConstructorExpectationSetup(Class<T> mockType) { this.arrayMerger = new ArrayMergerImpl(); this.mockType = mockType; }
public MockClassLoaderFactory(Class<?> testClass) { this(testClass, new PowerMockIgnorePackagesExtractorImpl().getPackagesToIgnore(testClass)); }
@Override public void initialize(ClassLoader classLoader) { if (classLoader instanceof MockClassLoader) { initialize(((MockClassLoader) classLoader)); } }
private boolean extractPackageToIgnore(final AnnotatedElement element, final Set<String> ignoredPackages) { boolean useGlobalFromAnnotation = addValueFromAnnotation(element, ignoredPackages); boolean useGlobalFromSuperclass = addValuesFromSuperclass((Class<?>) element, ignoredPackages); return useGlobalFromAnnotation & useGlobalFromSuperclass; }
private String[] getPackageToIgnoreWithGlobal(final String[] packageToIgnore) { String[] globalIgnore = getGlobalIgnore(); final String[] allPackageToIgnore; if (globalIgnore != null) { allPackageToIgnore = addGlobalIgnore(packageToIgnore, globalIgnore); } else { allPackageToIgnore = packageToIgnore; } return allPackageToIgnore; }
@Override public void refreshPolicies(ClassLoader classLoader) { if (classLoader instanceof MockClassLoader) { invokeInitializeInterceptionSettingsFromClassLoader((MockClassLoader) classLoader); } }
AbstractCommonTestSuiteChunkerImpl(Class<?>... testClasses) throws Exception { this.testClasses = testClasses; for (Class<?> clazz : testClasses) { chunkClass(clazz); } }
public MockPolicyInitializerImpl(Class<?> testClass) { this(getMockPolicies(testClass), testClass, false); }
private static Constructor<?>[] merge(Constructor<?> first, Constructor<?>... additional) { return new ArrayMergerImpl().mergeArrays(Constructor.class, new Constructor<?>[] { first }, additional); } }
private static Constructor<?>[] merge(Constructor<?> first, Constructor<?>... additional) { return new ArrayMergerImpl().mergeArrays(Constructor.class, new Constructor<?>[] { first }, additional); } }
private static String[] merge(String first, String... additional) { return new ArrayMergerImpl().mergeArrays(String.class, new String[] { first }, additional); }
private static Method[] merge(Method first, Method... additional) { return new ArrayMergerImpl().mergeArrays(Method.class, new Method[] { first }, additional); }
private static String[] merge(String first, String... additional) { return new ArrayMergerImpl().mergeArrays(String.class, new String[] { first }, additional); }
private static Method[] merge(Method first, Method... additional) { return new ArrayMergerImpl().mergeArrays(Method.class, new Method[] { first }, additional); }
private static Field[] merge(Field first, Field... additional) { return new ArrayMergerImpl().mergeArrays(Field.class, new Field[] { first }, additional); }