return declaration;
  }

  @Override
  public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
    return getAnnotation(annotationType) != null;
  }

  @Override
  @CheckForNull
  public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);
    for (Annotation annotation : annotations) {
      if (annotationType.isInstance(annotation)) {

    private boolean canUseToolChain(AvailableToolChains.ToolChainCandidate toolChain) {
        RequiresInstalledToolChain toolChainRequirement = target.getAnnotation(RequiresInstalledToolChain.class);
        if (toolChainRequirement != null) {
            return toolChain.meets(toolChainRequirement.value());
        }

    Method getGetter();

    String getPropertyName();

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

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    ImmutableMap<AnnotationCategory, Annotation> getAnnotations();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

     */
    @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"));
        assertThat((String) props.get("bbb"), is("3"));

                }
            }
        }

        private boolean suppressCleanupErrors() {
            return suppressCleanupErrors
                || testClass().getAnnotation(LeaksFileHandles.class) != null
                || description.getAnnotation(LeaksFileHandles.class) != null;
        }

        private Class<?> testClass() {
            return description.getTestClass();
        }

        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                ExpectedFailure expectedFailureAnnotation = method.getAnnotation(ExpectedFailure.class);
                boolean expectedToFail = expectedFailureAnnotation != null;
                Throwable failed = null;
                try {
                    base.evaluate();

import java.util.Optional;

public interface PropertyMetadata {
    String getPropertyName();

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

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    Optional<Annotation> getAnnotationForCategory(AnnotationCategory category);

    boolean hasAnnotationForCategory(AnnotationCategory category);

  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();
    TestSubtype spec = method.getAnnotation(TestSubtype.class);
    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))
        .isTrue();

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);
        Optional<String> reasonNotToTrackState = Optional.ofNullable(type.getAnnotation(UntrackedTask.class))
            .map(UntrackedTask::because);
        Map<String, Class<?>> processedMethods = new HashMap<>();

    void visitValidationFailures(TypeValidationContext validationContext);

    /**
     * Retrieves the annotation of the given type, if present on the type itself.
     */
    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);