return accessibleObject.isAnnotationPresent(annotationClass);
  }

  @Override
  @CheckForNull
  public final <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
    return accessibleObject.getAnnotation(annotationClass);
  }

  @Override
  public final Annotation[] getAnnotations() {
    return accessibleObject.getAnnotations();
  }

  @Override

    ComponentTypeModelRuleExtractor ruleHandler = new ComponentTypeModelRuleExtractor(schemaStore)

    @Override
    Class<? extends Annotation> getAnnotation() { return ComponentType }

    Class<?> ruleClass = Rules

    def "applies ComponentModelBasePlugin and creates component type rule"() {
        def mockRegistry = Mock(ModelRegistry)

        when:

    return accessibleObject.isAnnotationPresent(annotationClass);
  }

  @Override
  @CheckForNull
  public final <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
    return accessibleObject.getAnnotation(annotationClass);
  }

  @Override
  public final Annotation[] getAnnotations() {
    return accessibleObject.getAnnotations();
  }

  @Override

        boolean hasCycle = !dejaVu.add(original);
        Throwable throwable = original;
        type = throwable.getClass().getName();
        contextual = throwable.getClass().getAnnotation(Contextual.class) != null;
        assertionError = throwable instanceof AssertionError;
        try {

                Class<? extends Annotation> annotationType = annotation.annotationType();
                if (annotationType.getAnnotation(Inherited.class) != null) {
                    continue;
                }
                Retention retention = annotationType.getAnnotation(Retention.class);
                methodVisitor

        Class<?> generatedClass = generator.generate(BeanWithAnnotatedConstructor.class).getGeneratedClass();
        Constructor<?> constructor = generatedClass.getDeclaredConstructors()[0];

        assertThat(constructor.getAnnotation(Inject.class), notNullValue());
    }

    @Test
    public void includesAnnotationInformationForOverriddenConstructorWithName() {

            // Internal listeners are always allowed: we know their lifecycle and ensure there are no problems when configuration cache is reused.
            return true;
        }
        if (JavaPropertyReflectionUtil.getAnnotation(listener.getClass(), DeprecatedInGradleScope.class) != null) {
            // Explicitly unsupported Listener types are disallowed.
            return false;
        }

        }

        @Override
        public void visitValidationFailures(TypeValidationContext validationContext) {
        }

        @Override
        public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
            return Optional.empty();
        }
    };

    private final ImmutableSet<Class<? extends Annotation>> recordedTypeAnnotations;

private Class[] getParameterTypes(); public annotation.Annotation[] getAnnotations(); public annotation.Annotation getAnnotation(Class); public String toString(); } org/junit/runners/model/Annotatable.class package org.junit.runners.model; public abstract interface Annotatable { public abstract annotation.Annotation[] getAnnotations(); public abstract annotation.Annotation getAnnotation(Class); } org/junit/runners/model/Statement.class package org.junit.runners.model; public abstract synchronized class...

                return present;
            }

            private boolean locateAnnotation(Class<? extends Annotation> annotation) {
                for (Class<?> type : types) {
                    if (type.getAnnotation(annotation) != null) {
                        return true;
                    }
                }
                return false;
            }
        }
    }