spec = spec.subSpec
        }

        if (!spec.getReflection().isAnnotationPresent(RunFor) &&
            !spec.getReflection().isAnnotationPresent(Ignore) &&
            !spec.getReflection().isAnnotationPresent(NoRunFor)) {
            spec.getFeatures()
                .findAll {
                    !it.getFeatureMethod().getReflection().isAnnotationPresent(RunFor.class) &&

        );
    }

    private static InputBehavior determineBehavior(PropertyMetadata propertyMetadata) {
        return propertyMetadata.isAnnotationPresent(SkipWhenEmpty.class)
            ? InputBehavior.PRIMARY
            : propertyMetadata.isAnnotationPresent(Incremental.class)
            ? InputBehavior.INCREMENTAL
            : InputBehavior.NON_INCREMENTAL;
    }

        return accessors.values();
    }

    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
        return isAnnotationPresent(annotationType, getAccessor(PropertyAccessorType.GET_GETTER))
            || isAnnotationPresent(annotationType, getAccessor(PropertyAccessorType.IS_GETTER));
    }

    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testAbstractMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("abstractMethod");
    assertTrue(invokable.isPackagePrivate());
    assertTrue(invokable.isAbstract());
    assertFalse(invokable.isFinal());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testAbstractMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("abstractMethod");
    assertTrue(invokable.isPackagePrivate());
    assertTrue(invokable.isAbstract());
    assertFalse(invokable.isFinal());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

        Object qualifier = null;
        for (Annotation annotation : annotatedElement.getDeclaredAnnotations()) {
            if (annotation.annotationType().isAnnotationPresent(Qualifier.class)) {
                if (qualifier != null) {
                    throw new DIException("More than one qualifier annotation on " + annotatedElement);
                }

    def "handles methods annotated with @#annotationName"() {
        when:
        1 * ruleDefinition.isAnnotationPresent(annotation) >> false

        then:
        !ruleHandler.isSatisfiedBy(ruleDefinition)

        when:
        1 * ruleDefinition.isAnnotationPresent(annotation) >> true

        then:
        ruleHandler.isSatisfiedBy(ruleDefinition)

        where:

    public Class<T> getAnnotationType() {
        return annotationType;
    }

    @Override
    public boolean isSatisfiedBy(MethodRuleDefinition<?, ?> ruleDefinition) {
        return ruleDefinition.isAnnotationPresent(annotationType);
    }

    @Override
    public String getDescription() {
        return String.format("annotated with @%s", annotationType.getSimpleName());
   }

import javax.annotation.Nullable;
import java.lang.annotation.Annotation;
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);

import java.util.Optional;

public interface PropertyAnnotationMetadata extends Comparable<PropertyAnnotationMetadata> {
    Method getGetter();

    String getPropertyName();

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

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

    ImmutableMap<AnnotationCategory, Annotation> getAnnotations();