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)) {

     */
    @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"));

  }

  @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
  public final Annotation[] getDeclaredAnnotations() {

                    return;
                }
                final Method executeMethod = resource.getExecuteMethod();
                final Secured secured = executeMethod.getAnnotation(Secured.class);
                if (secured != null && user.hasRoles(secured.value())) {
                    return;
                }
                throw new UserRoleLoginException(RootAction.class);

producesType(reflect.Type); 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...

            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
        // TODO(cpovirk): Should we also check isNullableTypeVariable?
      }

      @Override
      boolean isNullable(Parameter param) {
        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
            || containsNullable(param.getAnnotatedType().getAnnotations())
            || isNullableTypeVariable(param.getAnnotatedType().getType());

}

// InAmbient returns true if a resource is in ambient data plane mode.
func InAmbient(obj metav1.Object) bool {
	if obj == nil {
		return false
	}
	switch t := obj.(type) {
	case *corev1.Pod:
		return t.GetAnnotations()[constants.AmbientRedirection] == constants.AmbientRedirectionEnabled
	case *corev1.Namespace:
		if t.GetLabels()["istio-injection"] == "enabled" {
			return false
		}

	}
	return retval
}

func extractRevisionFromPod(pod *corev1.Pod) string {
	return describe.GetRevisionFromPodAnnotation(pod.GetAnnotations())
}

func injectionDisabled(pod *corev1.Pod) bool {
	inject := pod.ObjectMeta.GetAnnotations()[annotation.SidecarInject.Name]
	if lbl, labelPresent := pod.ObjectMeta.GetLabels()[label.SidecarInject.Name]; labelPresent {
		inject = lbl
	}

		// Pod explicitly asked to not have ambient redirection enabled
		return false
	}
	return true
}

func podHasSidecar(pod *corev1.Pod) bool {
	if _, f := pod.GetAnnotations()[annotation.SidecarStatus.Name]; f {
		return true
	}
	return false
}

func IsZtunnelPod(systemNs string, pod *corev1.Pod) bool {
	return pod.Namespace == systemNs && pod.GetLabels()["app"] == "ztunnel"
}

    }

    private Class<?>[] getInterfaces(Class<?> superType) {
        if (superType.isInterface()) {
            return new Class<?>[] {superType};
        } else {
            for (Annotation a : superType.getAnnotations()) {
                Class<? extends Annotation> annotationType = a.annotationType();
                if ("org.eclipse.sisu.Typed".equals(annotationType.getName())