assertFalse(invokable.isStatic());
    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));
  }

    assertFalse(invokable.isStatic());
    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));
  }

  public void testGetField() {
    Field foo = Enums.getField(AnEnum.FOO);
    assertEquals("FOO", foo.getName());
    assertTrue(foo.isAnnotationPresent(ExampleAnnotation.class));

    Field bar = Enums.getField(AnEnum.BAR);
    assertEquals("BAR", bar.getName());
    assertFalse(bar.isAnnotationPresent(ExampleAnnotation.class));
  }

  @J2ktIncompatible
  @GwtIncompatible // Class.getClassLoader()

  }

  @SuppressLint("NewApi")
  private fun ExtensionContext.isFlaky(): Boolean {
    return (testMethod.orElseGet { null }?.isAnnotationPresent(Flaky::class.java) == true) ||
      (testClass.orElseGet { null }?.isAnnotationPresent(Flaky::class.java) == true)
  }

  @Synchronized private fun logEvents() {
    // Will be ineffective if test overrides the listener

      if (annotations == null) {
        annotations = new ArrayList<>();
        for (Annotation a : classOrMethod.getDeclaredAnnotations()) {
          if (a.annotationType().isAnnotationPresent(TesterAnnotation.class)) {
            annotations.add(a);
          }
        }
        annotations = unmodifiableList(annotations);
        annotationCache.put(classOrMethod, annotations);
      }

      if (annotations == null) {
        annotations = new ArrayList<>();
        for (Annotation a : classOrMethod.getDeclaredAnnotations()) {
          if (a.annotationType().isAnnotationPresent(TesterAnnotation.class)) {
            annotations.add(a);
          }
        }
        annotations = unmodifiableList(annotations);
        annotationCache.put(classOrMethod, annotations);
      }

  public static <T> Invokable<T, T> from(Constructor<T> constructor) {
    return new ConstructorInvokable<T>(constructor);
  }

  @Override
  public final boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
    return accessibleObject.isAnnotationPresent(annotationClass);
  }

  @Override
  @CheckForNull
  public final <A extends Annotation> A getAnnotation(Class<A> annotationClass) {

  static {
    ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
    for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Generates.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
    GENERATORS = builder.buildOrThrow();
  }

  private static final ImmutableMap<Class<?>, Method> EMPTY_GENERATORS;

    Map<MethodIdentifier, Method> identifiers = Maps.newHashMap();
    for (Class<?> supertype : supertypes) {
      for (Method method : supertype.getDeclaredMethods()) {
        if (method.isAnnotationPresent(Subscribe.class) && !method.isSynthetic()) {
          // TODO(cgdecker): Should check for a generic parameter type and error out
          Class<?>[] parameterTypes = method.getParameterTypes();
          checkArgument(

  static {
    ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
    for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Generates.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
    GENERATORS = builder.buildOrThrow();
  }

  private static final ImmutableMap<Class<?>, Method> EMPTY_GENERATORS;