private Object loadAnnotationEnableIfPresent() { boolean hasAnnotationEnabler = hasAnnotationEnablerClass(); if (!hasAnnotationEnabler) { return null; } try { return Whitebox.invokeConstructor(Class.forName(ANNOTATION_ENABLER, true, Thread.currentThread().getContextClassLoader())); } catch (Exception e) { throw new RuntimeException("PowerMock internal error, failed to load annotation enabler."); } }
newVM = Whitebox.invokeConstructor(vmClass, parameterTypes, new Object[]{ATTACH_PROVIDER, pid}); } catch (Exception e) { throw new RuntimeException(e);
private void invokeInitializeInterceptionSettingsFromClassLoader(MockClassLoader classLoader) { try { final int sizeOfPolicies = mockPolicyTypes.length; Object mockPolicies = Array.newInstance(Class.class, sizeOfPolicies); for (int i = 0; i < sizeOfPolicies; i++) { final Class<?> policyLoadedByClassLoader = Class.forName(mockPolicyTypes[i].getName(), false, classLoader); Array.set(mockPolicies, i, policyLoadedByClassLoader); } final Class<?> thisTypeLoadedByMockClassLoader = Class.forName(this.getClass() .getName(), false, classLoader); Object mockPolicyHandler = Whitebox.invokeConstructor(thisTypeLoadedByMockClassLoader, mockPolicies, true); Whitebox.invokeMethod(mockPolicyHandler, "initializeInterceptionSettings"); } catch (InvocationTargetException e) { final Throwable targetException = e.getTargetException(); if (targetException instanceof RuntimeException) { throw (RuntimeException) targetException; } else if (targetException instanceof Error) { throw (Error) targetException; } else { throw new RuntimeException(e); } } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new IllegalStateException("PowerMock internal error: Failed to load class.", e); } }
@Test void testClassLoader() throws Exception { MockTransformerService mockTransformerService = new MockTransformerService() { @Nonnull @Override public List<ITransformer> transformers() { return Stream.of(classNodeTransformer).collect(Collectors.toList()); } }; TransformStore transformStore = new TransformStore(); LaunchPluginHandler lph = new LaunchPluginHandler(); TransformationServiceDecorator sd = Whitebox.invokeConstructor(TransformationServiceDecorator.class, mockTransformerService); sd.gatherTransformers(transformStore); final Constructor<TransformingClassLoader> constructor = Whitebox.getConstructor(TransformingClassLoader.class, transformStore.getClass(), lph.getClass(), Path[].class); TransformingClassLoader tcl = constructor.newInstance(transformStore, lph, new Path[] {FileSystems.getDefault().getPath(".")}); final Class<?> aClass = Class.forName("cheese.Puffs", true, tcl); assertEquals(Whitebox.getField(aClass, "testfield").getType(), String.class); assertEquals(Whitebox.getField(aClass, "testfield").get(null), "CHEESE!"); }
@Test void testGatherTransformersNormally() throws Exception { MockTransformerService mockTransformerService = new MockTransformerService() { @Nonnull @Override public List<ITransformer> transformers() { return Stream.of(classNodeTransformer, methodNodeTransformer).collect(Collectors.toList()); } }; TransformStore store = new TransformStore(); TransformationServiceDecorator sd = Whitebox.invokeConstructor(TransformationServiceDecorator.class, mockTransformerService); sd.gatherTransformers(store); EnumMap<TransformTargetLabel.LabelType, TransformList<?>> transformers = Whitebox.getInternalState(store, "transformers"); Set<TransformTargetLabel> targettedClasses = Whitebox.getInternalState(store, "classNeedsTransforming"); assertAll( () -> assertTrue(transformers.containsKey(TransformTargetLabel.LabelType.CLASS)), () -> assertTrue(getTransformers(transformers.get(TransformTargetLabel.LabelType.CLASS)).values().stream().flatMap(Collection::stream).allMatch(s -> s == classNodeTransformer)), () -> assertTrue(targettedClasses.contains(new TransformTargetLabel("cheese.Puffs"))), () -> assertTrue(transformers.containsKey(TransformTargetLabel.LabelType.METHOD)), () -> assertTrue(getTransformers(transformers.get(TransformTargetLabel.LabelType.METHOD)).values().stream().flatMap(Collection::stream).allMatch(s -> s == methodNodeTransformer)), () -> assertTrue(targettedClasses.contains(new TransformTargetLabel("cheesy.PuffMethod"))) ); }
final TransformStore transformStore = new TransformStore(); final LaunchPluginHandler lph = new LaunchPluginHandler(); final ClassTransformer classTransformer = Whitebox.invokeConstructor(ClassTransformer.class, new Class[] { transformStore.getClass(), lph.getClass(), TransformingClassLoader.class }, new Object[] { transformStore, lph, null}); Whitebox.invokeMethod(transformStore, "addTransformer", new TransformTargetLabel("test.MyClass"), classTransformer()); byte[] result = Whitebox.invokeMethod(classTransformer, "transform", new Class[]{byte[].class, String.class}, new byte[0], "test.MyClass");