@Test
 public void testGenericMethodWithoutGenericExceptionTypes() throws Exception {
   DynamicType.Unloaded<?> unloaded =
       new ByteBuddy()
           .redefine(GenericMethod.class)
           .method(named(BAR))
           .intercept(FixedValue.nullValue())
           .make();
   Class<?> type =
       unloaded
           .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
           .getLoaded();
   MethodDescription createdMethod =
       new MethodDescription.ForLoadedMethod(type.getDeclaredMethod(BAR, Object.class));
   MethodDescription originalMethod =
       new MethodDescription.ForLoadedMethod(
           GenericMethod.class.getDeclaredMethod(BAR, Object.class));
   assertThat(createdMethod.getTypeVariables(), is(originalMethod.getTypeVariables()));
   assertThat(createdMethod.getReturnType(), is(originalMethod.getReturnType()));
   assertThat(
       createdMethod.getParameters().getOnly().getType(),
       is(originalMethod.getParameters().getOnly().getType()));
   assertThat(
       createdMethod.getExceptionTypes().getOnly(),
       is(originalMethod.getExceptionTypes().getOnly()));
 }
 public void apply()
     throws IllegalAccessException, InvocationTargetException, InstantiationException {
   if (type.isEnum()) {
     for (T instance : type.getEnumConstants()) {
       assertThat(
           instance.toString(),
           is(
               type.getCanonicalName().substring(type.getPackage().getName().length() + 1)
                   + "."
                   + ((Enum<?>) instance).name()));
     }
     return;
   }
   for (Constructor<?> constructor : type.getDeclaredConstructors()) {
     if (constructor.isSynthetic() && skipSynthetic) {
       continue;
     }
     constructor.setAccessible(true);
     Class<?>[] parameterTypes = constructor.getParameterTypes();
     Object[] actualArguments = new Object[parameterTypes.length];
     Object[] otherArguments = new Object[parameterTypes.length];
     int index = 0;
     for (Class<?> parameterType : parameterTypes) {
       putInstance(parameterType, actualArguments, otherArguments, index++);
     }
     int testIndex = 0;
     @SuppressWarnings("unchecked")
     T instance = (T) constructor.newInstance(actualArguments);
     assertThat(instance, is(instance));
     assertThat(instance, not(is((Object) null)));
     assertThat(instance, not(is(new Object())));
     Object similarInstance = constructor.newInstance(actualArguments);
     assertThat(instance.hashCode(), is(similarInstance.hashCode()));
     assertThat(instance, is(similarInstance));
     if (skipToString) {
       assertThat(instance.toString(), notNullValue());
     } else if (optionalToStringRegex == null) {
       checkString(instance);
     } else {
       assertThat(instance.toString(), new RegexMatcher(optionalToStringRegex));
     }
     for (Object otherArgument : otherArguments) {
       Object[] compareArguments = new Object[actualArguments.length];
       int argumentIndex = 0;
       for (Object actualArgument : actualArguments) {
         if (argumentIndex == testIndex) {
           compareArguments[argumentIndex] = otherArgument;
         } else {
           compareArguments[argumentIndex] = actualArgument;
         }
         argumentIndex++;
       }
       Object unlikeInstance = constructor.newInstance(compareArguments);
       assertThat(instance.hashCode(), not(is(unlikeInstance)));
       assertThat(instance, not(is(unlikeInstance)));
       testIndex++;
     }
   }
 }
    /*
     * (non-Javadoc)
     * @see org.mockito.stubbing.Answer#answer(org.mockito.invocation.InvocationOnMock)
     */
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {

      Class<?> returnType = invocation.getMethod().getReturnType();
      return returnType.equals(Boolean.class) || returnType.equals(boolean.class)
          ? true
          : DEFAULT.answer(invocation);
    }
 @Test
 public void testSourceName() throws Exception {
   for (Class<?> type : standardTypes) {
     if (type.isArray()) {
       assertThat(describe(type).getActualName(), is(type.getComponentType().getName() + "[]"));
     } else {
       assertThat(describe(type).getActualName(), is(type.getName()));
     }
   }
 }
 @Test
 public void testEnclosingType() throws Exception {
   for (Class<?> type : standardTypes) {
     assertThat(
         describe(type).getEnclosingType(),
         type.getEnclosingClass() == null
             ? nullValue(TypeDescription.class)
             : is((TypeDescription) new TypeDescription.ForLoadedType(type.getEnclosingClass())));
   }
 }
Exemplo n.º 6
0
 @Test
 public void testSetClassName() throws Exception {
   Intent intent = new Intent();
   Class<? extends IntentTest> thisClass = getClass();
   intent.setClassName("package.name", thisClass.getName());
   assertSame(thisClass.getName(), intent.getComponent().getClassName());
   assertEquals("package.name", intent.getComponent().getPackageName());
   ShadowIntent si = shadowOf(intent);
   assertSame(si.getIntentClass(), thisClass);
 }
 @Test
 public void testGenericField() throws Exception {
   DynamicType.Unloaded<?> unloaded = new ByteBuddy().redefine(GenericField.class).make();
   Class<?> type =
       unloaded
           .load(ClassLoadingStrategy.BOOTSTRAP_LOADER, ClassLoadingStrategy.Default.WRAPPER)
           .getLoaded();
   FieldDescription createdField = new FieldDescription.ForLoadedField(type.getDeclaredField(FOO));
   FieldDescription originalField =
       new FieldDescription.ForLoadedField(GenericField.class.getDeclaredField(FOO));
   assertThat(createdField.getType(), is(originalField.getType()));
 }
  /** simple case. */
  @Test
  public void simple() {
    Class<? extends DirectFileOutputDescription> aClass =
        generate(new Description("Testing", name(MockData.class)));
    assertThat(DirectFileOutputDescription.class.isAssignableFrom(aClass), is(true));
    assertThat(Modifier.isAbstract(aClass.getModifiers()), is(true));

    assertThat(aClass, hasGetter("getModelType"));
    assertThat(aClass, not(hasGetter("getBasePath")));
    assertThat(aClass, not(hasGetter("getResourcePattern")));
    assertThat(aClass, not(hasGetter("getFormat")));
  }
 public static Class<?> malform(Class<?> type) throws Exception {
   ClassReader classReader = new ClassReader(type.getName());
   ClassWriter classWriter = new ClassWriter(classReader, 0);
   classReader.accept(new SignatureMalformer(classWriter), 0);
   ClassLoader classLoader =
       new ByteArrayClassLoader(
           null,
           Collections.singletonMap(type.getName(), classWriter.toByteArray()),
           null,
           ByteArrayClassLoader.PersistenceHandler.MANIFEST,
           PackageDefinitionStrategy.NoOp.INSTANCE);
   return classLoader.loadClass(type.getName());
 }
 @SuppressWarnings("unchecked")
 private void apply(Object mock) {
   for (Refinement refinement : refinements) {
     ParameterizedType generic =
         (ParameterizedType) refinement.getClass().getGenericInterfaces()[0];
     Class<?> restrained =
         generic.getActualTypeArguments()[0] instanceof ParameterizedType
             ? (Class<?>) ((ParameterizedType) generic.getActualTypeArguments()[0]).getRawType()
             : (Class<?>) generic.getActualTypeArguments()[0];
     if (restrained.isInstance(mock)) {
       refinement.apply(mock);
     }
   }
 }
 private void assertAnnotations(Class<?> type) {
   assertThat(
       describe(type).getDeclaredAnnotations(),
       hasItems(
           new AnnotationList.ForLoadedAnnotation(type.getDeclaredAnnotations())
               .toArray(new AnnotationDescription[type.getDeclaredAnnotations().length])));
   assertThat(
       describe(type).getDeclaredAnnotations().size(), is(type.getDeclaredAnnotations().length));
   assertThat(
       describe(type).getInheritedAnnotations(),
       hasItems(
           new AnnotationList.ForLoadedAnnotation(type.getAnnotations())
               .toArray(new AnnotationDescription[type.getAnnotations().length])));
   assertThat(describe(type).getInheritedAnnotations().size(), is(type.getAnnotations().length));
 }
Exemplo n.º 12
0
  @SuppressWarnings("unchecked")
  @Test
  public void test() throws Exception {
    assertThat(compile("input/Example.java"), is(true));

    URLClassLoader loader = new URLClassLoader(new URL[] {res("input/")});
    Class<?> exampleClass = loader.loadClass("Example");
    Object exampleObj = exampleClass.newInstance();
    assertThat(
        (List<String>)
            exampleClass
                .getMethod("transform", List.class)
                .invoke(exampleObj, Arrays.<Integer>asList(1, 2, 3)),
        is(Arrays.<String>asList("2", "4", "6")));
  }
 @Test
 @ToolsJarRule.Enforce
 public void testAgentSelfInitializationAuxiliaryTypes() throws Exception {
   assertThat(ByteBuddyAgent.installOnOpenJDK(), instanceOf(Instrumentation.class));
   ClassFileTransformer classFileTransformer =
       new AgentBuilder.Default()
           .rebase(isAnnotatedWith(ShouldRebase.class), ElementMatchers.is(classLoader))
           .transform(new QuxTransformer())
           .installOnByteBuddyAgent();
   try {
     Class<?> type = classLoader.loadClass(Qux.class.getName());
     assertThat(type.getDeclaredMethod(FOO).invoke(type.newInstance()), is((Object) (FOO + BAR)));
   } finally {
     ByteBuddyAgent.getInstrumentation().removeTransformer(classFileTransformer);
   }
 }
 private void checkString(T instance) {
   assertThat(
       instance.toString(),
       CoreMatchers.startsWith(
           type.getCanonicalName().substring(type.getPackage().getName().length() + 1) + "{"));
   assertThat(instance.toString(), endsWith("}"));
   Class<?> currentType = type;
   do {
     for (Field field : type.getDeclaredFields()) {
       if (!field.isSynthetic()
           && !Modifier.isStatic(field.getModifiers())
           && !ignoredFields.contains(field.getName())) {
         assertThat(instance.toString(), containsString(field.getName()));
       }
     }
   } while ((currentType = currentType.getSuperclass()) != Object.class);
 }
 @Test
 public void testEnclosingMethod() throws Exception {
   for (Class<?> type : standardTypes) {
     Matcher<MethodDescription> matcher;
     if (type.getEnclosingMethod() != null) {
       matcher =
           CoreMatchers.<MethodDescription>is(
               new MethodDescription.ForLoadedMethod(type.getEnclosingMethod()));
     } else if (type.getEnclosingConstructor() != null) {
       matcher =
           CoreMatchers.<MethodDescription>is(
               new MethodDescription.ForLoadedConstructor(type.getEnclosingConstructor()));
     } else {
       matcher = nullValue(MethodDescription.class);
     }
     assertThat(describe(type).getEnclosingMethod(), matcher);
   }
 }
 @Test
 @ToolsJarRule.Enforce
 public void testAgentWithoutSelfInitializationWithNativeMethodPrefix() throws Exception {
   assertThat(ByteBuddyAgent.installOnOpenJDK(), instanceOf(Instrumentation.class));
   ClassFileTransformer classFileTransformer =
       new AgentBuilder.Default()
           .disableSelfInitialization()
           .withNativeMethodPrefix(QUX)
           .rebase(isAnnotatedWith(ShouldRebase.class), ElementMatchers.is(classLoader))
           .transform(new FooTransformer())
           .installOnByteBuddyAgent();
   try {
     Class<?> type = classLoader.loadClass(Baz.class.getName());
     assertThat(type.getDeclaredMethod(FOO).invoke(type.newInstance()), is((Object) BAR));
     assertThat(type.getDeclaredMethod(QUX + FOO), notNullValue(Method.class));
   } finally {
     ByteBuddyAgent.getInstrumentation().removeTransformer(classFileTransformer);
   }
 }
  /**
   * generate concrete class.
   *
   * @throws Exception if failed
   */
  @Test
  public void concrete() throws Exception {
    Description description = new Description("Testing", name(MockData.class));
    description.setBasePath("base-path");
    description.setResourcePattern("*");
    description.setFormatClassName(name(MockDataFormat.class));

    Class<? extends DirectFileOutputDescription> aClass = generate(description);
    assertThat(DirectFileOutputDescription.class.isAssignableFrom(aClass), is(true));
    assertThat(Modifier.isAbstract(aClass.getModifiers()), is(false));

    DirectFileOutputDescription object = aClass.newInstance();
    assertThat(object.getModelType(), is((Object) MockData.class));
    assertThat(object.getBasePath(), is("base-path"));
    assertThat(object.getResourcePattern(), is("*"));
    assertThat(object.getOrder(), is(Arrays.<String>asList()));
    assertThat(object.getDeletePatterns(), is(Arrays.<String>asList()));
    assertThat(object.getFormat(), is((Object) MockDataFormat.class));
  }
 @Test
 public void testIsPackageDescription() throws Exception {
   assertThat(
       describe(
               Class.forName(
                   Sample.class.getPackage().getName()
                       + "."
                       + PackageDescription.PACKAGE_CLASS_NAME))
           .isPackageType(),
       is(true));
   assertThat(describe(Object.class).isPackageType(), is(false));
 }
 private Object replace(Class<?> type, ApplicableGenerator generator, boolean alternative) {
   for (Creator<?> creator : creators) {
     ParameterizedType generic =
         (ParameterizedType) creator.getClass().getGenericInterfaces()[0];
     Class<?> restrained =
         generic.getActualTypeArguments()[0] instanceof ParameterizedType
             ? (Class<?>) ((ParameterizedType) generic.getActualTypeArguments()[0]).getRawType()
             : (Class<?>) generic.getActualTypeArguments()[0];
     if (type.isAssignableFrom(restrained)) {
       return creator.create();
     }
   }
   return generator.generate(type, alternative);
 }
 private Object generate(Class<?> type, boolean alternative) {
   for (Generator<?> generator : generators) {
     ParameterizedType generic =
         (ParameterizedType) generator.getClass().getGenericInterfaces()[0];
     Class<?> restrained =
         generic.getActualTypeArguments()[0] instanceof ParameterizedType
             ? (Class<?>) ((ParameterizedType) generic.getActualTypeArguments()[0]).getRawType()
             : (Class<?>) generic.getActualTypeArguments()[0];
     if (type.isAssignableFrom(restrained)) {
       type = generator.generate();
     }
   }
   return type == String.class ? alternative ? OTHER_STRING : DEFAULT_STRING : mock(type);
 }
 private void putInstance(
     Class<?> parameterType, Object actualArguments, Object otherArguments, int index) {
   Object actualArgument, otherArgument;
   if (parameterType == boolean.class) {
     actualArgument = DEFAULT_BOOLEAN;
     otherArgument = OTHER_BOOLEAN;
   } else if (parameterType == byte.class) {
     actualArgument = DEFAULT_BYTE;
     otherArgument = OTHER_BYTE;
   } else if (parameterType == char.class) {
     actualArgument = DEFAULT_CHAR;
     otherArgument = OTHER_CHAR;
   } else if (parameterType == short.class) {
     actualArgument = DEFAULT_SHORT;
     otherArgument = OTHER_SHORT;
   } else if (parameterType == int.class) {
     actualArgument = DEFAULT_INT;
     otherArgument = OTHER_INT;
   } else if (parameterType == long.class) {
     actualArgument = DEFAULT_LONG;
     otherArgument = OTHER_LONG;
   } else if (parameterType == float.class) {
     actualArgument = DEFAULT_FLOAT;
     otherArgument = OTHER_FLOAT;
   } else if (parameterType == double.class) {
     actualArgument = DEFAULT_DOUBLE;
     otherArgument = OTHER_DOUBLE;
   } else if (parameterType.isEnum()) {
     Object[] enumConstants = parameterType.getEnumConstants();
     if (enumConstants.length == 1) {
       throw new IllegalArgumentException("Enum with only one constant: " + parameterType);
     }
     actualArgument = enumConstants[0];
     otherArgument = enumConstants[1];
   } else if (parameterType.isArray()) {
     actualArgument = Array.newInstance(parameterType.getComponentType(), 1);
     otherArgument = Array.newInstance(parameterType.getComponentType(), 1);
     putInstance(parameterType.getComponentType(), actualArgument, otherArgument, 0);
   } else {
     actualArgument = creator.replace(parameterType, generator, false);
     refinement.apply(actualArgument);
     otherArgument = creator.replace(parameterType, generator, true);
     refinement.apply(otherArgument);
   }
   Array.set(actualArguments, index, actualArgument);
   Array.set(otherArguments, index, otherArgument);
 }
 public void applyBasic()
     throws IllegalAccessException, InvocationTargetException, InstantiationException {
   for (Constructor<?> constructor : type.getDeclaredConstructors()) {
     if (constructor.isSynthetic() && skipSynthetic) {
       continue;
     }
     constructor.setAccessible(true);
     Class<?>[] parameterTypes = constructor.getParameterTypes();
     Object[] actualArguments = new Object[parameterTypes.length];
     Object[] otherArguments = new Object[parameterTypes.length];
     int index = 0;
     for (Class<?> parameterType : parameterTypes) {
       putInstance(parameterType, actualArguments, otherArguments, index++);
     }
     @SuppressWarnings("unchecked")
     T instance = (T) constructor.newInstance(actualArguments);
     checkString(instance);
     assertThat(instance, is(instance));
     assertThat(instance, not(is((Object) null)));
     assertThat(instance, not(is(new Object())));
     assertThat(instance, not(is(constructor.newInstance(otherArguments))));
   }
 }
 @Test
 public void testToString() throws Exception {
   for (Class<?> type : TYPES) {
     assertThat(describe(type).toString(), is(type.toString()));
   }
 }
 @Test
 public void testCanonicalName() throws Exception {
   for (Class<?> type : standardTypes) {
     assertThat(describe(type).getCanonicalName(), is(type.getCanonicalName()));
   }
 }
 @Test
 public void testIsLocalClass() throws Exception {
   for (Class<?> type : standardTypes) {
     assertThat(describe(type).isLocalClass(), is(type.isLocalClass()));
   }
 }
 @Test
 public void testModifiers() throws Exception {
   for (Class<?> type : standardTypes) {
     assertThat(describe(type).getModifiers(), is(type.getModifiers()));
   }
 }
 @Test
 public void testName() throws Exception {
   for (Class<?> type : TYPES) {
     assertThat(describe(type).getName(), is(type.getName()));
   }
 }