executor.execute(runnable);
          }
        };
    Future<?> future = newFutureInstance();
    future
        .getClass()
        .getMethod(
            "setFuture",
            future.getClass().getClassLoader().loadClass(ListenableFuture.class.getName()))
        .invoke(future, badFuture);

    }

    def "formats message with a single method problem"() {
        given:
        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add(String.class.getMethod("indexOf", String), "rule", "is not annotated with anything.")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:

    }

    @Override
    public Class<?> getOwner() {
        return owner;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Method getMethod() {
        return method;
    }

        val loadedClass = loadClass()
        val method = loadedClass.getMethod(methodName)
        val instance = loadedClass.getDeclaredConstructor().newInstance()
        return method.invoke(instance)
    }

    fun callStatic(methodName: String): Any {
        val loadedClass = loadClass()
        val method = loadedClass.getMethod(methodName)
        return method.invoke(loadedClass)
    }

    RespondWithPathToParent(String pathToParent) {
        this.pathToParent = pathToParent
    }

    @Override
    Object respond(IMockInvocation invocation) {
        if (invocation.getMethod().name == "getPathToParent") {
            return pathToParent
        }
        return EmptyOrDummyResponse.INSTANCE.respond(invocation)
    }

 */
public class AnnotationUtilTest {

    /**
     * @throws Exception
     */
    @Hoge(bbb = "3")
    @Test
    public void testGetProperties() throws Exception {
        final Method m = ClassUtil.getMethod(getClass(), "testGetProperties");
        final Annotation anno = m.getAnnotation(Hoge.class);
        final Map<String, Object> props = AnnotationUtil.getProperties(anno);
        assertThat((String) props.get("aaa"), is("123"));

    private GeneratedSubclasses() {
    }

    public static Class<?> unpack(Class<?> type) {
        if (GeneratedSubclass.class.isAssignableFrom(type)) {
            try {
                return (Class<?>) type.getMethod("generatedFrom").invoke(null);
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        return type;
    }

import javax.annotation.Nullable;
import java.lang.annotation.Annotation;
import java.util.List;

public interface MethodRuleDefinition<R, S> {
    WeaklyTypeReferencingMethod<?, R> getMethod();

    String getMethodName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    @Nullable
    <A extends Annotation> A getAnnotation(Class<A> annotationType);

        then:
        generatedType.getMethod("getValues").returnType == List
        generatedType.getMethod("getValues").genericReturnType.actualTypeArguments == [String]

        generatedType.getMethod("getOptional").returnType == Optional
        generatedType.getMethod("getOptional").genericReturnType.actualTypeArguments == [Boolean]

    Class<?> getOwner();

    String getName();

    Type getServiceType();

    Type[] getParameterTypes();

    @Nullable
    Object invoke(Object target, @Nullable Object... args);

    Method getMethod();