Removed test utilities.

raphw · Oct 25, 2016 · 7926da5 · 7926da5
1 parent fc9434f
commit 7926da5
Show file tree

Hide file tree

Showing 38 changed files with 1,497 additions and 715 deletions.
diff --git a/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/FixedValue.java b/byte-buddy-dep/src/main/java/net/bytebuddy/implementation/FixedValue.java
@@ -19,10 +19,11 @@
 import static net.bytebuddy.matcher.ElementMatchers.named;
 
 /**
- * This implementation returns a fixed value for a method. Other than the
+ * This implementation returns a fixed value for a method. Other than the {@link net.bytebuddy.implementation.StubMethod}
- * {@link net.bytebuddy.implementation.StubMethod} implementation, this implementation allows
+ * implementation, this implementation allows to determine a specific value which must be assignable to the returning value
- * to determine a specific value which must be assignable to the returning value of any instrumented method. Otherwise,
+ * of any instrumented method. Otherwise, an exception will be thrown.
- * an exception will be thrown.
+ *
+ * @see FieldAccessor
  */
 public abstract class FixedValue implements Implementation {
 

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/AbstractImplementationTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/AbstractImplementationTest.java
diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/DefaultMethodCallTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/DefaultMethodCallTest.java
@@ -1,9 +1,11 @@
 package net.bytebuddy.implementation;
 
+import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.description.type.TypeDefinition;
 import net.bytebuddy.description.type.TypeDescription;
 import net.bytebuddy.description.type.TypeList;
 import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
 import net.bytebuddy.test.utility.JavaVersionRule;
 import net.bytebuddy.test.utility.ObjectPropertyAssertion;
 import org.junit.Rule;
@@ -15,13 +17,14 @@
 import java.util.Collections;
 import java.util.List;
 
-import static net.bytebuddy.matcher.ElementMatchers.*;
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
+import static net.bytebuddy.matcher.ElementMatchers.not;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-public class DefaultMethodCallTest extends AbstractImplementationTest {
+public class DefaultMethodCallTest {
 
     private static final String FOO = "foo", QUX = "qux";
 
@@ -39,11 +42,12 @@ public class DefaultMethodCallTest extends AbstractImplementationTest {
     @Test
     @JavaVersionRule.Enforce(8)
     public void testUnambiguousDefaultMethod() throws Exception {
-        DynamicType.Loaded<?> loaded = implement(Object.class,
+        DynamicType.Loaded<?> loaded = new ByteBuddy()
-                DefaultMethodCall.unambiguousOnly(),
+                .subclass(Object.class)
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD))
-                isMethod().and(not(isDeclaredBy(Object.class))),
+                .intercept(DefaultMethodCall.unambiguousOnly())
-                Class.forName(SINGLE_DEFAULT_METHOD));
+                .make()
+                .load(Class.forName(SINGLE_DEFAULT_METHOD).getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         Method method = loaded.getLoaded().getDeclaredMethod(FOO);
         Object instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
@@ -53,11 +57,11 @@ public void testUnambiguousDefaultMethod() throws Exception {
     @Test(expected = IllegalStateException.class)
     @JavaVersionRule.Enforce(8)
     public void testAmbiguousDefaultMethodThrowsException() throws Exception {
-        implement(Object.class,
+        new ByteBuddy()
-                DefaultMethodCall.unambiguousOnly(),
+                .subclass(Object.class)
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE))
-                not(isDeclaredBy(Object.class)),
+                .intercept(DefaultMethodCall.unambiguousOnly())
-                Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE));
+                .make();
     }
 
     @Test
@@ -77,11 +81,12 @@ private void assertConflictChoice(Class<?> preferredInterface,
                                       Class<?> secondInterface,
                                       Object expectedResult,
                                       Class<?>... preferredInterfaces) throws Exception {
-        DynamicType.Loaded<?> loaded = implement(Object.class,
+        DynamicType.Loaded<?> loaded = new ByteBuddy()
-                DefaultMethodCall.prioritize(preferredInterfaces),
+                .subclass(Object.class)
-                getClass().getClassLoader(),
+                .implement(preferredInterface, secondInterface)
-                isMethod().and(not(isDeclaredBy(Object.class))),
+                .intercept(DefaultMethodCall.prioritize(preferredInterfaces))
-                preferredInterface, secondInterface);
+                .make()
+                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         Method method = loaded.getLoaded().getDeclaredMethod(FOO);
         Object instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
@@ -91,39 +96,43 @@ private void assertConflictChoice(Class<?> preferredInterface,
     @Test(expected = IllegalStateException.class)
     @JavaVersionRule.Enforce(8)
     public void testUnrelatedPreferredDefaultMethodThrowsException() throws Exception {
-        implement(Object.class,
+        new ByteBuddy()
-                DefaultMethodCall.prioritize(Class.forName(NON_OVERRIDING_INTERFACE)),
+                .subclass(Object.class)
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE))
-                not(isDeclaredBy(Object.class)),
+                .intercept(DefaultMethodCall.prioritize(Class.forName(NON_OVERRIDING_INTERFACE)))
-                Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE));
+                .make();
     }
 
     @Test(expected = IllegalStateException.class)
     @JavaVersionRule.Enforce(8)
     public void testNonDeclaredDefaultMethodThrowsException() throws Exception {
-        implement(Class.forName(SINGLE_DEFAULT_METHOD_CLASS),
+        new ByteBuddy()
-                DefaultMethodCall.unambiguousOnly(),
+                .subclass(Class.forName(SINGLE_DEFAULT_METHOD_CLASS))
-                getClass().getClassLoader(),
+                .method(not(isDeclaredBy(Object.class)))
-                not(isDeclaredBy(Object.class)));
+                .intercept(DefaultMethodCall.unambiguousOnly())
+                .make();
     }
 
     @Test(expected = IllegalStateException.class)
     @JavaVersionRule.Enforce(8)
     public void testNonDeclaredPreferredDefaultMethodThrowsException() throws Exception {
-        implement(Class.forName(SINGLE_DEFAULT_METHOD_CLASS),
+        new ByteBuddy()
-                DefaultMethodCall.prioritize(Class.forName(SINGLE_DEFAULT_METHOD)),
+                .subclass(Class.forName(SINGLE_DEFAULT_METHOD_CLASS))
-                getClass().getClassLoader(),
+                .method(not(isDeclaredBy(Object.class)))
-                not(isDeclaredBy(Object.class)));
+                .intercept(DefaultMethodCall.prioritize(Class.forName(SINGLE_DEFAULT_METHOD)))
+                .make();
     }
 
     @Test
     @JavaVersionRule.Enforce(8)
     public void testDeclaredAndImplementedMethod() throws Exception {
-        DynamicType.Loaded<?> loaded = implement(Class.forName(SINGLE_DEFAULT_METHOD_CLASS),
+        DynamicType.Loaded<?> loaded = new ByteBuddy()
-                DefaultMethodCall.unambiguousOnly(),
+                .subclass(Class.forName(SINGLE_DEFAULT_METHOD_CLASS))
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD))
-                isMethod().and(not(isDeclaredBy(Object.class))),
+                .method(not(isDeclaredBy(Object.class)))
-                Class.forName(SINGLE_DEFAULT_METHOD));
+                .intercept(DefaultMethodCall.unambiguousOnly())
+                .make()
+                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         Method method = loaded.getLoaded().getDeclaredMethod(FOO);
         Object instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
@@ -133,21 +142,24 @@ public void testDeclaredAndImplementedMethod() throws Exception {
     @Test(expected = IllegalStateException.class)
     @JavaVersionRule.Enforce(8)
     public void testDeclaredAndImplementedAmbiguousMethodThrowsException() throws Exception {
-        implement(Class.forName(SINGLE_DEFAULT_METHOD_CLASS),
+        new ByteBuddy()
-                DefaultMethodCall.unambiguousOnly(),
+                .subclass(Class.forName(SINGLE_DEFAULT_METHOD_CLASS))
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE))
-                not(isDeclaredBy(Object.class)),
+                .method(not(isDeclaredBy(Object.class)))
-                Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE));
+                .intercept(DefaultMethodCall.unambiguousOnly())
+                .make();
     }
 
     @Test
     @JavaVersionRule.Enforce(8)
     public void testDeclaredAndImplementedAmbiguousMethodWithPreference() throws Exception {
-        DynamicType.Loaded<?> loaded = implement(Class.forName(SINGLE_DEFAULT_METHOD_CLASS),
+        DynamicType.Loaded<?> loaded = new ByteBuddy()
-                DefaultMethodCall.prioritize(Class.forName(SINGLE_DEFAULT_METHOD)),
+                .subclass(Class.forName(SINGLE_DEFAULT_METHOD_CLASS))
-                getClass().getClassLoader(),
+                .implement(Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE))
-                isMethod().and(not(isDeclaredBy(Object.class))),
+                .method(not(isDeclaredBy(Object.class)))
-                Class.forName(SINGLE_DEFAULT_METHOD), Class.forName(CONFLICTING_INTERFACE));
+                .intercept(DefaultMethodCall.prioritize(Class.forName(SINGLE_DEFAULT_METHOD)))
+                .make()
+                .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         Method method = loaded.getLoaded().getDeclaredMethod(FOO);
         Object instance = loaded.getLoaded().getDeclaredConstructor().newInstance();

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/ExceptionMethodTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/ExceptionMethodTest.java
@@ -1,25 +1,33 @@
 package net.bytebuddy.implementation;
 
+import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.description.method.MethodList;
 import net.bytebuddy.description.type.TypeDescription;
 import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
 import net.bytebuddy.test.utility.CallTraceable;
 import net.bytebuddy.test.utility.ObjectPropertyAssertion;
 import org.hamcrest.CoreMatchers;
 import org.junit.Test;
 
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
 import static org.hamcrest.CoreMatchers.*;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.when;
 
-public class ExceptionMethodTest extends AbstractImplementationTest {
+public class ExceptionMethodTest {
 
     private static final String FOO = "foo", BAR = "bar";
 
     @Test
     public void testWithoutMessage() throws Exception {
-        DynamicType.Loaded<Foo> loaded = implement(Foo.class, ExceptionMethod.throwing(RuntimeException.class));
+        DynamicType.Loaded<Foo> loaded = new ByteBuddy()
+                .subclass(Foo.class)
+                .method(isDeclaredBy(Foo.class))
+                .intercept(ExceptionMethod.throwing(RuntimeException.class))
+                .make()
+                .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
@@ -38,7 +46,12 @@ public void testWithoutMessage() throws Exception {
 
     @Test
     public void testWithMessage() throws Exception {
-        DynamicType.Loaded<Foo> loaded = implement(Foo.class, ExceptionMethod.throwing(RuntimeException.class, BAR));
+        DynamicType.Loaded<Foo> loaded = new ByteBuddy()
+                .subclass(Foo.class)
+                .method(isDeclaredBy(Foo.class))
+                .intercept(ExceptionMethod.throwing(RuntimeException.class, BAR))
+                .make()
+                .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
@@ -57,7 +70,12 @@ public void testWithMessage() throws Exception {
 
     @Test
     public void testWithNonDeclaredCheckedException() throws Exception {
-        DynamicType.Loaded<Foo> loaded = implement(Foo.class, ExceptionMethod.throwing(Exception.class));
+        DynamicType.Loaded<Foo> loaded = new ByteBuddy()
+                .subclass(Foo.class)
+                .method(isDeclaredBy(Foo.class))
+                .intercept(ExceptionMethod.throwing(Exception.class))
+                .make()
+                .load(Foo.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
         assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
         assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
@@ -75,7 +93,7 @@ public void testWithNonDeclaredCheckedException() throws Exception {
     }
 
     @Test
-    public void testEqualsHashCode() throws Exception {
+    public void testObjectProperties() throws Exception {
         ObjectPropertyAssertion.of(ExceptionMethod.class).apply();
         ObjectPropertyAssertion.of(ExceptionMethod.ConstructionDelegate.ForDefaultConstructor.class).refine(new ObjectPropertyAssertion.Refinement<TypeDescription>() {
             @Override

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/FieldAccessorExceptionTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/FieldAccessorExceptionTest.java
@@ -1,24 +1,37 @@
 package net.bytebuddy.implementation;
 
+import net.bytebuddy.ByteBuddy;
 import org.junit.Test;
 
-public class FieldAccessorExceptionTest extends AbstractImplementationTest {
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
 
-    private static final String FOO = "foo";
+public class FieldAccessorExceptionTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void testFinalFieldSetter() throws Exception {
-        implement(Foo.class, FieldAccessor.ofBeanProperty());
+        new ByteBuddy()
+                .subclass(Foo.class)
+                .method(isDeclaredBy(Foo.class))
+                .intercept(FieldAccessor.ofBeanProperty())
+                .make();
     }
 
     @Test(expected = IllegalStateException.class)
     public void testFieldNoVisibleField() throws Exception {
-        implement(Bar.class, FieldAccessor.ofBeanProperty());
+        new ByteBuddy()
+                .subclass(Bar.class)
+                .method(isDeclaredBy(Bar.class))
+                .intercept(FieldAccessor.ofBeanProperty())
+                .make();
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testFieldNoBeanMethodName() throws Exception {
-        implement(Qux.class, FieldAccessor.ofBeanProperty());
+        new ByteBuddy()
+                .subclass(Qux.class)
+                .method(isDeclaredBy(Qux.class))
+                .intercept(FieldAccessor.ofBeanProperty())
+                .make();
     }
 
     @SuppressWarnings("unused")

diff --git a/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/FieldAccessorNonBeanTest.java b/byte-buddy-dep/src/test/java/net/bytebuddy/implementation/FieldAccessorNonBeanTest.java
@@ -1,15 +1,18 @@
 package net.bytebuddy.implementation;
 
+import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.dynamic.DynamicType;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
 import net.bytebuddy.test.utility.CallTraceable;
 import org.junit.Test;
 
 import java.lang.reflect.Field;
 
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-public class FieldAccessorNonBeanTest extends AbstractImplementationTest {
+public class FieldAccessorNonBeanTest {
 
     private static final String FOO = "foo";
 
@@ -19,7 +22,12 @@ public class FieldAccessorNonBeanTest extends AbstractImplementationTest {
 
     @Test
     public void testExplicitNameSetter() throws Exception {
-        DynamicType.Loaded<SampleSetter> loaded = implement(SampleSetter.class, FieldAccessor.ofField(FOO));
+        DynamicType.Loaded<SampleSetter> loaded = new ByteBuddy()
+                .subclass(SampleSetter.class)
+                .method(isDeclaredBy(SampleSetter.class))
+                .intercept(FieldAccessor.ofField(FOO))
+                .make()
+                .load(SampleSetter.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         SampleSetter sampleSetter = loaded.getLoaded().getDeclaredConstructor().newInstance();
         Field field = SampleSetter.class.getDeclaredField(FOO);
         field.setAccessible(true);
@@ -31,7 +39,12 @@ public void testExplicitNameSetter() throws Exception {
 
     @Test
     public void testExplicitNameGetter() throws Exception {
-        DynamicType.Loaded<SampleGetter> loaded = implement(SampleGetter.class, FieldAccessor.ofField(FOO));
+        DynamicType.Loaded<SampleGetter> loaded = new ByteBuddy()
+                .subclass(SampleGetter.class)
+                .method(isDeclaredBy(SampleGetter.class))
+                .intercept(FieldAccessor.ofField(FOO))
+                .make()
+                .load(SampleSetter.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
         SampleGetter sampleGetter = loaded.getLoaded().getDeclaredConstructor().newInstance();
         Field field = SampleGetter.class.getDeclaredField(FOO);
         field.setAccessible(true);