Added further documentation and tests.

raphw · Mar 31, 2015 · 9a123b9 · 9a123b9
1 parent 5c37f15
commit 9a123b9
Show file tree

Hide file tree

Showing 7 changed files with 391 additions and 44 deletions.
diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/instrumentation/InvokeDynamic.java b/byte-buddy-dep/src/main/java/net/bytebuddy/instrumentation/InvokeDynamic.java
diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/AbstractInstrumentationTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/AbstractInstrumentationTest.java
@@ -18,6 +18,7 @@
 import net.bytebuddy.instrumentation.type.TypeDescription;
 import net.bytebuddy.instrumentation.type.TypeList;
 import net.bytebuddy.matcher.ElementMatcher;
+import net.bytebuddy.test.utility.DebuggingWrapper;
 import org.hamcrest.CoreMatchers;
 import org.objectweb.asm.Opcodes;
 

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/FixedValueTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/FixedValueTest.java
@@ -75,7 +75,7 @@ public void testMethodHandleConstantPoolValue() throws Exception {
     }
 
     private static Object makeMethodHandle() throws Exception {
-        Object lookup = Class.forName("java.lang.invoke.MethodHandles").getDeclaredMethod("lookup").invoke(null);
+        Object lookup = Class.forName("java.lang.invoke.MethodHandles").getDeclaredMethod("publicLookup").invoke(null);
         return JavaType.METHOD_HANDLES_LOOKUP.load().getDeclaredMethod("findVirtual", Class.class, String.class, JavaType.METHOD_TYPE.load())
                 .invoke(lookup, Qux.class, BAR, makeMethodType(Object.class));
     }

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/InvokeDynamicTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/instrumentation/InvokeDynamicTest.java
@@ -5,8 +5,9 @@
 import net.bytebuddy.test.utility.JavaVersionRule;
 import net.bytebuddy.test.utility.ObjectPropertyAssertion;
 import net.bytebuddy.test.utility.PrecompiledTypeClassLoader;
+import net.bytebuddy.utility.JavaInstance;
+import net.bytebuddy.utility.JavaType;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.MethodRule;
@@ -120,19 +121,21 @@ public void testBootstrapWithArrayArgumentsWithArguments() throws Exception {
         TypeDescription typeDescription = new TypeDescription.ForLoadedType(type);
         DynamicType.Loaded<Simple> dynamicType = instrument(Simple.class,
                 InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP_ARRAY_ARGUMENTS)).getOnly(),
-                        INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS)
+                        INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, makeMethodType(CLASS), makeMethodHandle())
                         .withoutImplicitArguments(),
                 classLoader,
                 isDeclaredBy(Simple.class));
         assertThat(dynamicType.getLoaded().newInstance().foo(), is(FOO));
         Object[] arguments = (Object[]) field.get(null);
-        assertThat(arguments.length, is(6));
+        assertThat(arguments.length, is(8));
         assertThat(arguments[0], is((Object) INTEGER));
         assertThat(arguments[1], is((Object) LONG));
         assertThat(arguments[2], is((Object) FLOAT));
         assertThat(arguments[3], is((Object) DOUBLE));
         assertThat(arguments[4], is((Object) FOO));
         assertThat(arguments[5], is((Object) CLASS));
+        assertThat(arguments[6], is(makeMethodType(CLASS)));
+        assertThat(JavaInstance.MethodHandle.of(arguments[7]), is(JavaInstance.MethodHandle.of(makeMethodHandle())));
     }
 
     @Test
@@ -144,19 +147,21 @@ public void testBootstrapWithExplicitArgumentsWithArguments() throws Exception {
         TypeDescription typeDescription = new TypeDescription.ForLoadedType(type);
         DynamicType.Loaded<Simple> dynamicType = instrument(Simple.class,
                 InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP_EXPLICIT_ARGUMENTS)).getOnly(),
-                        INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS)
+                        INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, makeMethodType(CLASS), makeMethodHandle())
                         .withoutImplicitArguments(),
                 classLoader,
                 isDeclaredBy(Simple.class));
         assertThat(dynamicType.getLoaded().newInstance().foo(), is(FOO));
         Object[] arguments = (Object[]) field.get(null);
-        assertThat(arguments.length, is(6));
+        assertThat(arguments.length, is(8));
         assertThat(arguments[0], is((Object) INTEGER));
         assertThat(arguments[1], is((Object) LONG));
         assertThat(arguments[2], is((Object) FLOAT));
         assertThat(arguments[3], is((Object) DOUBLE));
         assertThat(arguments[4], is((Object) FOO));
         assertThat(arguments[5], is((Object) CLASS));
+        assertThat(arguments[6], is(makeMethodType(CLASS)));
+        assertThat(JavaInstance.MethodHandle.of(arguments[7]), is(JavaInstance.MethodHandle.of(makeMethodHandle())));
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -169,8 +174,7 @@ public void testBootstrapWithExplicitArgumentsWithoutArgumentsThrowsException()
     @Test
     @JavaVersionRule.Enforce(7)
     public void testBootstrapOfMethodsWithParametersPrimitive() throws Exception {
-        Class<?> type = classLoader.loadClass(ARGUMENT_BOOTSTRAP);
+        TypeDescription typeDescription = new TypeDescription.ForLoadedType(classLoader.loadClass(ARGUMENT_BOOTSTRAP));
-        TypeDescription typeDescription = new TypeDescription.ForLoadedType(type);
         Object value = new Object();
         DynamicType.Loaded<Simple> dynamicType = instrument(Simple.class,
                 InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP)).getOnly())
@@ -184,11 +188,14 @@ public void testBootstrapOfMethodsWithParametersPrimitive() throws Exception {
                         .withLongValue(LONG)
                         .withFloatValue(FLOAT)
                         .withDoubleValue(DOUBLE)
-                        .withValue(FOO, CLASS, value),
+                        .withType(new TypeDescription.ForLoadedType(CLASS))
+                        .withInstance(JavaInstance.MethodType.of(makeMethodType(CLASS)), JavaInstance.MethodHandle.of(makeMethodHandle()))
+                        .withValue(FOO, CLASS, makeMethodType(CLASS), makeMethodHandle(), value),
                 classLoader,
                 isDeclaredBy(Simple.class));
         assertThat(dynamicType.getLoaded().newInstance().foo(),
-                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + FOO + CLASS + value));
+                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + CLASS + makeMethodType(CLASS)
+                        + makeMethodHandle() + FOO + CLASS + makeMethodType(CLASS) + makeMethodHandle() + value));
     }
 
     @Test
@@ -201,12 +208,12 @@ public void testBootstrapOfMethodsWithParametersWrapperConstantPool() throws Exc
                 InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP)).getOnly())
                         .invoke(BAR, String.class)
                         .withoutImplicitArguments()
-                        .withValue(BOOLEAN, BYTE, SHORT, CHARACTER, INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, value),
+                        .withValue(BOOLEAN, BYTE, SHORT, CHARACTER, INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, makeMethodType(CLASS), makeMethodHandle(), value),
                 classLoader,
                 isDeclaredBy(Simple.class));
         assertThat(dynamicType.getLoaded().getDeclaredFields().length, is(1));
         assertThat(dynamicType.getLoaded().newInstance().foo(),
-                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + FOO + CLASS + value));
+                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + FOO + CLASS + makeMethodType(CLASS) + makeMethodHandle() + value));
     }
 
     @Test
@@ -219,12 +226,14 @@ public void testBootstrapOfMethodsWithParametersWrapperReference() throws Except
                 InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP)).getOnly())
                         .invoke(BAR, String.class)
                         .withoutImplicitArguments()
-                        .withReference(BOOLEAN, BYTE, SHORT, CHARACTER, INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, value),
+                        .withReference(BOOLEAN, BYTE, SHORT, CHARACTER, INTEGER, LONG, FLOAT, DOUBLE, FOO, CLASS, makeMethodType(CLASS))
+                        .withReference(makeMethodHandle()).as(JavaType.METHOD_HANDLE.load()) // avoid direct method handle
+                        .withReference(value),
                 classLoader,
-                isDeclaredBy(Simple.class));
+        isDeclaredBy(Simple.class));
-        assertThat(dynamicType.getLoaded().getDeclaredFields().length, is(11));
+        assertThat(dynamicType.getLoaded().getDeclaredFields().length, is(13));
         assertThat(dynamicType.getLoaded().newInstance().foo(),
-                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + FOO + CLASS + value));
+                is("" + BOOLEAN + BYTE + SHORT + CHARACTER + INTEGER + LONG + FLOAT + DOUBLE + FOO + CLASS + makeMethodType(CLASS) + makeMethodHandle() + value));
     }
 
     @Test
@@ -415,6 +424,7 @@ public void testObjectProperties() throws Exception {
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ForClassValue.class).apply();
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ForStaticField.class).apply();
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ForThisInstance.class).apply();
+        ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ForJavaInstance.class).apply();
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.Resolved.Simple.class).apply();
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.class).apply();
         ObjectPropertyAssertion.of(InvokeDynamic.InvocationProvider.ArgumentProvider.ConstantPoolWrapper.WrappingArgumentProvider.class).apply();
@@ -424,6 +434,16 @@ public void testObjectProperties() throws Exception {
         ObjectPropertyAssertion.of(InvokeDynamic.TerminationHandler.ForChainedInvocation.class).apply();
     }
 
+    private static Object makeMethodType(Class<?> returnType, Class<?>... parameterType) throws Exception {
+        return JavaType.METHOD_TYPE.load().getDeclaredMethod("methodType", Class.class, Class[].class).invoke(null, returnType, parameterType);
+    }
+
+    private static Object makeMethodHandle() throws Exception {
+        Object lookup = Class.forName("java.lang.invoke.MethodHandles").getDeclaredMethod("publicLookup").invoke(null);
+        return JavaType.METHOD_HANDLES_LOOKUP.load().getDeclaredMethod("findVirtual", Class.class, String.class, JavaType.METHOD_TYPE.load())
+                .invoke(lookup, Simple.class, FOO, makeMethodType(String.class));
+    }
+
     public static class Simple {
 
         public String foo() {
@@ -433,7 +453,7 @@ public String foo() {
 
     public static class SimpleWithField {
 
-        protected String foo;
+        public String foo;
 
         public String foo() {
             return null;

diff --git a/...y/test/precompiled/ArgumentBootstrap.java → ...y/test/precompiled/ArgumentBootstrap.java b/...y/test/precompiled/ArgumentBootstrap.java → ...y/test/precompiled/ArgumentBootstrap.java
@@ -1,9 +1,6 @@
 package net.bytebuddy.test.precompiled;
 
-import java.lang.invoke.CallSite;
+import java.lang.invoke.*;
-import java.lang.invoke.ConstantCallSite;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 
 public class ArgumentBootstrap {
 
@@ -20,10 +17,15 @@ public static String foo(boolean arg0,
                              long arg5,
                              float arg6,
                              double arg7,
-                             String arg8,
+                             Class<?> arg8,
-                             Class<?> arg9,
+                             MethodType arg9,
-                             Object arg10) {
+                             MethodHandle arg10,
-        return "" + arg0 + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
+                             String arg11,
+                             Class<?> arg12,
+                             MethodType arg13,
+                             MethodHandle arg14,
+                             Object arg15) {
+        return "" + arg0 + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12 + arg13 + arg14 + arg15;
     }
 
     public static String bar(Boolean arg0,
@@ -36,8 +38,10 @@ public static String bar(Boolean arg0,
                              Double arg7,
                              String arg8,
                              Class<?> arg9,
-                             Object arg10) {
+                             MethodType arg10,
-        return "" + arg0 + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
+                             MethodHandle arg11,
+                             Object arg12) {
+        return "" + arg0 + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10 + arg11 + arg12;
     }
 
     public static String qux(String arg) {

diff --git a/.../test/precompiled/ParameterBootstrap.java → .../test/precompiled/ParameterBootstrap.java b/.../test/precompiled/ParameterBootstrap.java → .../test/precompiled/ParameterBootstrap.java
@@ -1,9 +1,6 @@
 package net.bytebuddy.test.precompiled;
 
-import java.lang.invoke.CallSite;
+import java.lang.invoke.*;
-import java.lang.invoke.ConstantCallSite;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 
 public class ParameterBootstrap {
 
@@ -28,9 +25,11 @@ public static CallSite bootstrapExplicitArguments(MethodHandles.Lookup lookup,
                                                       float arg2,
                                                       double arg3,
                                                       String arg4,
-                                                      Class<?> arg5)
+                                                      Class<?> arg5,
+                                                      MethodType arg6,
+                                                      MethodHandle arg7)
             throws NoSuchMethodException, IllegalAccessException {
-        ParameterBootstrap.arguments = new Object[]{arg0, arg1, arg2, arg3, arg4, arg5};
+        ParameterBootstrap.arguments = new Object[]{arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7};
         return new ConstantCallSite(lookup.findStatic(ParameterBootstrap.class, methodName, methodType));
     }
 

diff --git a/byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/ParameterNames.java b/byte-buddy-dep/src/test/resources/net/bytebuddy/test/precompiled/ParameterNames.java
@@ -1,5 +1,8 @@
 package net.bytebuddy.test.precompiled;
 
+/**
+ * This class must be compiled with enabling {@code -parameters} for the related tests to work!
+ */
 public abstract class ParameterNames {
 
     public ParameterNames(String first, final int second) {