org.hibernate.engine.spi.SelfDirtinessTracker#net.bytebuddy.implementation.FixedValue源码实例Demo

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryLookupOnly() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryLookupAndStringOnly() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryNoVarargs() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryVarargs() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class,
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryNested() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class,
                    bootstrap), JavaConstant.Dynamic.bootstrap(BAR, bootstrap.getMethod("bootstrap",
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    Object[].class)))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorLookupOnly() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorLookupAndStringOnly() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorNoVarargs() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorVarargs() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class,
                    Object[].class))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorNested() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    String.class,
                    Class.class,
                    bootstrap), JavaConstant.Dynamic.bootstrap(BAR, bootstrap.getConstructor(
                    Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                    Object[].class)))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testInvoke() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofInvocation(SampleClass.class.getMethod("make"))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(SampleClass.class));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testConstruct() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofInvocation(SampleClass.class.getConstructor())))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(SampleClass.class));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@AgentAttachmentRule.Enforce(retransformsClasses = true)
public void testFromAgentClassReloadingStrategy() throws Exception {
    assertThat(ByteBuddyAgent.install(), instanceOf(Instrumentation.class));
    Foo foo = new Foo();
    assertThat(foo.foo(), is(FOO));
    ClassReloadingStrategy classReloadingStrategy = ClassReloadingStrategy.fromInstalledAgent();
    new ByteBuddy()
            .redefine(Foo.class)
            .method(named(FOO))
            .intercept(FixedValue.value(BAR))
            .make()
            .load(Foo.class.getClassLoader(), classReloadingStrategy);
    try {
        assertThat(foo.foo(), is(BAR));
    } finally {
        classReloadingStrategy.reset(Foo.class);
        assertThat(foo.foo(), is(FOO));
    }
}
 

@Test
@AgentAttachmentRule.Enforce(retransformsClasses = true)
@JavaVersionRule.Enforce(atMost = 10) // Wait for mechanism in sun.misc.Unsafe to define class.
public void testFromAgentClassWithAuxiliaryReloadingStrategy() throws Exception {
    assertThat(ByteBuddyAgent.install(), instanceOf(Instrumentation.class));
    Foo foo = new Foo();
    assertThat(foo.foo(), is(FOO));
    ClassReloadingStrategy classReloadingStrategy = ClassReloadingStrategy.fromInstalledAgent();
    String randomName = FOO + RandomString.make();
    new ByteBuddy()
            .redefine(Foo.class)
            .method(named(FOO))
            .intercept(FixedValue.value(BAR))
            .make()
            .include(new ByteBuddy().subclass(Object.class).name(randomName).make())
            .load(Foo.class.getClassLoader(), classReloadingStrategy);
    try {
        assertThat(foo.foo(), is(BAR));
    } finally {
        classReloadingStrategy.reset(Foo.class);
        assertThat(foo.foo(), is(FOO));
    }
    assertThat(Class.forName(randomName), notNullValue(Class.class));
}
 

@Test
@AgentAttachmentRule.Enforce(redefinesClasses = true)
public void testRedefinitionReloadingStrategy() throws Exception {
    assertThat(ByteBuddyAgent.install(), instanceOf(Instrumentation.class));
    Foo foo = new Foo();
    assertThat(foo.foo(), is(FOO));
    ClassReloadingStrategy classReloadingStrategy = ClassReloadingStrategy.fromInstalledAgent(ClassReloadingStrategy.Strategy.REDEFINITION);
    new ByteBuddy()
            .redefine(Foo.class)
            .method(named(FOO))
            .intercept(FixedValue.value(BAR))
            .make()
            .load(Foo.class.getClassLoader(), classReloadingStrategy);
    try {
        assertThat(foo.foo(), is(BAR));
    } finally {
        classReloadingStrategy.reset(Foo.class);
        assertThat(foo.foo(), is(FOO));
    }
}
 

@Test
@AgentAttachmentRule.Enforce(retransformsClasses = true)
public void testRetransformationReloadingStrategy() throws Exception {
    assertThat(ByteBuddyAgent.install(), instanceOf(Instrumentation.class));
    Foo foo = new Foo();
    assertThat(foo.foo(), is(FOO));
    ClassReloadingStrategy classReloadingStrategy = ClassReloadingStrategy.fromInstalledAgent(ClassReloadingStrategy.Strategy.RETRANSFORMATION);
    new ByteBuddy()
            .redefine(Foo.class)
            .method(named(FOO))
            .intercept(FixedValue.value(BAR))
            .make()
            .load(Foo.class.getClassLoader(), classReloadingStrategy);
    try {
        assertThat(foo.foo(), is(BAR));
    } finally {
        classReloadingStrategy.reset(Foo.class);
        assertThat(foo.foo(), is(FOO));
    }
}
 

private Collection<File> addClass(String name) throws IOException {
    return new ByteBuddy()
            .subclass(Object.class)
            .name(name)
            .defineMethod(FOO, String.class, Visibility.PUBLIC).intercept(FixedValue.value(FOO))
            .defineMethod(BAR, String.class, Visibility.PUBLIC).intercept(FixedValue.value(BAR))
            .make()
            .saveIn(target)
            .values();
}
 

private Collection<File> addClass(String name) throws IOException {
    return new ByteBuddy()
            .subclass(Object.class)
            .name(name)
            .defineMethod(FOO, String.class, Visibility.PUBLIC).intercept(FixedValue.value(FOO))
            .defineMethod(BAR, String.class, Visibility.PUBLIC).intercept(FixedValue.value(BAR))
            .make()
            .saveIn(project)
            .values();
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantFactoryWithArguments() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO,
                    bootstrap.getMethod("bootstrap",
                            Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                            String.class,
                            Class.class,
                            int.class,
                            long.class,
                            float.class,
                            double.class,
                            String.class,
                            Class.class,
                            Class.forName("java.lang.invoke.MethodHandle"),
                            Class.forName("java.lang.invoke.MethodType")),
                    42, 42L, 42f, 42d, FOO,
                    TypeDescription.ForLoadedType.of(Object.class),
                    JavaConstant.MethodHandle.ofLoaded(methodHandle()),
                    JavaConstant.MethodType.ofLoaded(methodType()))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testDynamicConstantConstructorWithArguments() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.bootstrap(FOO,
                    bootstrap.getConstructor(
                            Class.forName("java.lang.invoke.MethodHandles$Lookup"),
                            String.class,
                            Class.class,
                            int.class,
                            long.class,
                            float.class,
                            double.class,
                            String.class,
                            Class.class,
                            Class.forName("java.lang.invoke.MethodHandle"),
                            Class.forName("java.lang.invoke.MethodType")),
                    42, 42L, 42f, 42d, FOO,
                    TypeDescription.ForLoadedType.of(Object.class),
                    JavaConstant.MethodHandle.ofLoaded(methodHandle()),
                    JavaConstant.MethodType.ofLoaded(methodType()))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testNullConstant() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofNullConstant()))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), nullValue(Object.class));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testPrimitiveType() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofPrimitiveType(void.class)))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance((Object) void.class));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testEnumeration() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofEnumeration(SampleEnum.INSTANCE)))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance((Object) SampleEnum.INSTANCE));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testField() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofField(SampleClass.class.getDeclaredField("FOO"))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(SampleClass.FOO));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testFieldWithSelfDeclaredType() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofField(SampleClass.class.getDeclaredField("BAR"))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance((Object) SampleClass.BAR));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testConstructWithArguments() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofInvocation(bootstrap.getConstructor(
                    int.class,
                    long.class,
                    float.class,
                    double.class,
                    String.class,
                    Class.class,
                    Class.forName("java.lang.invoke.MethodHandle"),
                    Class.forName("java.lang.invoke.MethodType")),
                    42, 42L, 42f, 42d, FOO,
                    TypeDescription.ForLoadedType.of(Object.class),
                    JavaConstant.MethodHandle.ofLoaded(methodHandle()),
                    JavaConstant.MethodType.ofLoaded(methodType()))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testInvokeWithArguments() throws Exception {
    Class<?> bootstrap = Class.forName("net.bytebuddy.test.precompiled.DynamicConstantBootstrap");
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofInvocation(bootstrap.getMethod("make",
                    int.class,
                    long.class,
                    float.class,
                    double.class,
                    String.class,
                    Class.class,
                    Class.forName("java.lang.invoke.MethodHandle"),
                    Class.forName("java.lang.invoke.MethodType")),
                    42, 42L, 42f, 42d, FOO,
                    TypeDescription.ForLoadedType.of(Object.class),
                    JavaConstant.MethodHandle.ofLoaded(methodHandle()),
                    JavaConstant.MethodType.ofLoaded(methodType()))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(bootstrap));
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), sameInstance(baz.getDeclaredMethod(FOO).invoke(foo)));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testStaticFieldVarHandle() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofVarHandle(SampleClass.class.getDeclaredField("FOO"))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(Class.forName("java.lang.invoke.VarHandle")));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testNonStaticFieldVarHandle() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofVarHandle(SampleClass.class.getDeclaredField("qux"))))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(Class.forName("java.lang.invoke.VarHandle")));
}
 

@Test
@JavaVersionRule.Enforce(11)
public void testArrayVarHandle() throws Exception {
    Class<? extends Foo> baz = new ByteBuddy()
            .subclass(Foo.class)
            .method(isDeclaredBy(Foo.class))
            .intercept(FixedValue.value(JavaConstant.Dynamic.ofArrayVarHandle(Object[].class)))
            .make()
            .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(baz.getDeclaredFields().length, is(0));
    assertThat(baz.getDeclaredMethods().length, is(1));
    Foo foo = baz.getDeclaredConstructor().newInstance();
    assertThat(baz.getDeclaredMethod(FOO).invoke(foo), instanceOf(Class.forName("java.lang.invoke.VarHandle")));
}